WeightedGraph.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Text;

namespace WinFormsApp1
{
    public class WeightedGraph
    {
        public class Node
        {
            public int Id { get; set; }
            public Point Position { get; set; }
            public Color Color { get; set; }
            public bool Visited { get; set; }
            public int Distance { get; set; }
            public Node Parent { get; set; }

            public Node(int id, Point position)
            {
                Id = id;
                Position = position;
                Color = Color.LightBlue;
                Visited = false;
                Distance = int.MaxValue;
                Parent = null;
            }
        }

        public class Edge
        {
            public Node From { get; set; }
            public Node To { get; set; }
            public int Weight { get; set; }
            public int Flow { get; set; }
            public int Capacity { get; set; }
            public Color Color { get; set; }
            public bool IsHighlighted { get; set; }
            public bool IsInResult { get; set; }

            public Edge(Node from, Node to, int weight)
            {
                From = from;
                To = to;
                Weight = weight;
                Capacity = weight;
                Flow = 0;
                Color = Color.Gray;
                IsHighlighted = false;
                IsInResult = false;
            }
        }

        public List<Node> Nodes { get; private set; }
        public List<Edge> Edges { get; private set; }
        public bool IsDirected { get; set; }

        public WeightedGraph(bool isDirected = false)
        {
            Nodes = new List<Node>();
            Edges = new List<Edge>();
            IsDirected = isDirected;
        }

        public Node AddNode(Point position)
        {
            int id = Nodes.Count;
            var node = new Node(id, position);
            Nodes.Add(node);
            return node;
        }

        public void RemoveNode(Node node)
        {
            Edges.RemoveAll(e => e.From == node || e.To == node);
            Nodes.Remove(node);
            for (int i = 0; i < Nodes.Count; i++)
            {
                Nodes[i].Id = i;
            }
        }

        public Edge AddEdge(Node from, Node to, int weight)
        {
            if (from == to) return null;
            
            var existing = Edges.Find(e => e.From == from && e.To == to);
            if (existing != null)
            {
                existing.Weight = weight;
                existing.Capacity = weight;
                return existing;
            }

            var edge = new Edge(from, to, weight);
            Edges.Add(edge);
            return edge;
        }

        public void RemoveEdge(Edge edge)
        {
            Edges.Remove(edge);
        }

        public Edge GetEdge(Node from, Node to)
        {
            return Edges.Find(e => 
                (e.From == from && e.To == to) || 
                (!IsDirected && e.From == to && e.To == from));
        }

        public List<Node> GetNeighbors(Node node)
        {
            var neighbors = new List<Node>();
            foreach (var edge in Edges)
            {
                if (edge.From == node)
                    neighbors.Add(edge.To);
                else if (!IsDirected && edge.To == node)
                    neighbors.Add(edge.From);
            }
            return neighbors;
        }

        public int GetWeight(Node from, Node to)
        {
            var edge = GetEdge(from, to);
            return edge?.Weight ?? 0;
        }

        public void ResetState()
        {
            foreach (var node in Nodes)
            {
                node.Visited = false;
                node.Color = Color.LightBlue;
                node.Distance = int.MaxValue;
                node.Parent = null;
            }
            foreach (var edge in Edges)
            {
                edge.Color = Color.Gray;
                edge.IsHighlighted = false;
                edge.IsInResult = false;
                edge.Flow = 0;
            }
        }

        public void ResetFlow()
        {
            foreach (var edge in Edges)
            {
                edge.Flow = 0;
                edge.Color = Color.Gray;
                edge.IsHighlighted = false;
            }
        }

        public int[,] GetAdjacencyMatrix()
        {
            int n = Nodes.Count;
            int[,] matrix = new int[n, n];
            
            foreach (var edge in Edges)
            {
                matrix[edge.From.Id, edge.To.Id] = edge.Weight;
                if (!IsDirected)
                    matrix[edge.To.Id, edge.From.Id] = edge.Weight;
            }
            
            return matrix;
        }

        public void AdjustPositions(int width, int height)
        {
            if (Nodes.Count == 0) return;

            int minX = int.MaxValue, minY = int.MaxValue;
            int maxX = int.MinValue, maxY = int.MinValue;

            foreach (var node in Nodes)
            {
                minX = Math.Min(minX, node.Position.X);
                minY = Math.Min(minY, node.Position.Y);
                maxX = Math.Max(maxX, node.Position.X);
                maxY = Math.Max(maxY, node.Position.Y);
            }

            int margin = 60;
            int rangeX = Math.Max(maxX - minX, 1);
            int rangeY = Math.Max(maxY - minY, 1);

            foreach (var node in Nodes)
            {
                int newX = margin + (node.Position.X - minX) * (width - 2 * margin) / rangeX;
                int newY = margin + (node.Position.Y - minY) * (height - 2 * margin) / rangeY;
                node.Position = new Point(newX, newY);
            }
        }

        public void SaveToFile(string path)
        {
            using (var writer = new StreamWriter(path))
            {
                writer.WriteLine($"DIRECTED:{IsDirected}");
                writer.WriteLine($"NODES:{Nodes.Count}");
                
                foreach (var node in Nodes)
                {
                    writer.WriteLine($"NODE:{node.Id},{node.Position.X},{node.Position.Y}");
                }
                
                writer.WriteLine($"EDGES:{Edges.Count}");
                foreach (var edge in Edges)
                {
                    writer.WriteLine($"EDGE:{edge.From.Id},{edge.To.Id},{edge.Weight}");
                }
            }
        }

        public static WeightedGraph LoadFromFile(string path)
        {
            var graph = new WeightedGraph();
            
            using (var reader = new StreamReader(path))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    if (line.StartsWith("DIRECTED:"))
                    {
                        graph.IsDirected = bool.Parse(line.Substring(9));
                    }
                    else if (line.StartsWith("NODE:"))
                    {
                        var parts = line.Substring(5).Split(',');
                        int x = int.Parse(parts[1]);
                        int y = int.Parse(parts[2]);
                        graph.AddNode(new Point(x, y));
                    }
                    else if (line.StartsWith("EDGE:"))
                    {
                        var parts = line.Substring(5).Split(',');
                        int fromId = int.Parse(parts[0]);
                        int toId = int.Parse(parts[1]);
                        int weight = int.Parse(parts[2]);
                        graph.AddEdge(graph.Nodes[fromId], graph.Nodes[toId], weight);
                    }
                }
            }
            
            return graph;
        }

        public void SaveToCsv(string path)
        {
            var matrix = GetAdjacencyMatrix();
            int n = Nodes.Count;

            using (var writer = new StreamWriter(path))
            {
                // Заголовок с метаданными
                writer.WriteLine($"#DIRECTED={IsDirected}");
                
                // Позиции узлов
                writer.WriteLine("#POSITIONS");
                foreach (var node in Nodes)
                {
                    writer.WriteLine($"#POS:{node.Id},{node.Position.X},{node.Position.Y}");
                }
                
                // Матрица смежности
                writer.WriteLine("#MATRIX");
                writer.Write(";");
                for (int i = 0; i < n; i++)
                    writer.Write($"{i};");
                writer.WriteLine();

                for (int i = 0; i < n; i++)
                {
                    writer.Write($"{i};");
                    for (int j = 0; j < n; j++)
                        writer.Write($"{matrix[i, j]};");
                    writer.WriteLine();
                }
            }
        }

        public static WeightedGraph LoadFromCsv(string path)
        {
            var graph = new WeightedGraph();
            var positions = new Dictionary<int, Point>();

            using (var reader = new StreamReader(path))
            {
                string line;
                bool readingMatrix = false;
                int row = -1;
                int n = 0;
                int[,] matrix = null;

                while ((line = reader.ReadLine()) != null)
                {
                    if (line.StartsWith("#DIRECTED="))
                    {
                        graph.IsDirected = bool.Parse(line.Substring(10));
                    }
                    else if (line.StartsWith("#POS:"))
                    {
                        var parts = line.Substring(5).Split(',');
                        int id = int.Parse(parts[0]);
                        int x = int.Parse(parts[1]);
                        int y = int.Parse(parts[2]);
                        positions[id] = new Point(x, y);
                    }
                    else if (line == "#MATRIX")
                    {
                        readingMatrix = true;
                    }
                    else if (readingMatrix && !line.StartsWith("#"))
                    {
                        var parts = line.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                        
                        if (row == -1)
                        {
                            // Заголовок
                            n = parts.Length - 1;
                            matrix = new int[n, n];
                            // Создаём узлы
                            for (int i = 0; i < n; i++)
                            {
                                Point pos = positions.ContainsKey(i) ? positions[i] : new Point(100 + i * 80, 100);
                                graph.AddNode(pos);
                            }
                        }
                        else if (row < n)
                        {
                            for (int j = 1; j <= n && j < parts.Length; j++)
                            {
                                if (int.TryParse(parts[j], out int val) && val != 0)
                                {
                                    graph.AddEdge(graph.Nodes[row], graph.Nodes[j - 1], val);
                                }
                            }
                        }
                        row++;
                    }
                }
            }

            return graph;
        }

        public string GetAdjacencyMatrixString()
        {
            var sb = new StringBuilder();
            var matrix = GetAdjacencyMatrix();
            int n = Nodes.Count;

            // Заголовок
            sb.Append("     ");
            for (int i = 0; i < n; i++)
                sb.Append($"{i,4}");
            sb.AppendLine();
            sb.AppendLine(new string('-', 5 + n * 4));

            for (int i = 0; i < n; i++)
            {
                sb.Append($"{i,3} |");
                for (int j = 0; j < n; j++)
                    sb.Append($"{matrix[i, j],4}");
                sb.AppendLine();
            }

            return sb.ToString();
        }

        public void GenerateRandom(int nodeCount, int edgeCount, int width, int height, 
            int minWeight = 1, int maxWeight = 10)
        {
            Nodes.Clear();
            Edges.Clear();

            Random rand = new Random();
            int margin = 60;

            int attempts = 0;
            while (Nodes.Count < nodeCount && attempts < nodeCount * 100)
            {
                int x = rand.Next(margin, Math.Max(margin + 1, width - margin));
                int y = rand.Next(margin, Math.Max(margin + 1, height - margin));

                bool tooClose = false;
                foreach (var existing in Nodes)
                {
                    double dist = Math.Sqrt(
                        Math.Pow(x - existing.Position.X, 2) +
                        Math.Pow(y - existing.Position.Y, 2));
                    if (dist < 80)
                    {
                        tooClose = true;
                        break;
                    }
                }

                if (!tooClose)
                    AddNode(new Point(x, y));

                attempts++;
            }

            int addedEdges = 0;
            attempts = 0;
            while (addedEdges < edgeCount && attempts < edgeCount * 20)
            {
                int from = rand.Next(Nodes.Count);
                int to = rand.Next(Nodes.Count);

                if (from != to && GetEdge(Nodes[from], Nodes[to]) == null)
                {
                    int weight = rand.Next(minWeight, maxWeight + 1);
                    AddEdge(Nodes[from], Nodes[to], weight);
                    addedEdges++;
                }
                attempts++;
            }
        }
    }
}