Zpiu

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
 
namespace Zpiu
{
    public class Program
    {
        static void Main( string[] args )
        {
            Console.WriteLine( "Projekt z przedmiotu zarzadzanie produkcja i uslugami" );
            do
            {
                Console.WriteLine();
                Console.WriteLine( "1. Wczytaj dane z pliku i oblicz" );
                Console.WriteLine( "2. Wygeneruj pusty plik z danymi" );
                Console.WriteLine( "3. Wyjscie" );
 
                ConsoleKeyInfo keyInfo = Console.ReadKey();
                switch ( keyInfo.Key )
                {
                    case ConsoleKey.D1:
                        Oblicz();
                        break;
                    case ConsoleKey.D2:
                        WygenerujPusteDane();
                        break;
                    case ConsoleKey.D3:
                        return;
                    default:
                        break;
                }
            } while ( true );
        }
 
        private static void Oblicz()
        {
            Console.WriteLine();
            int[,] dane = WczytajDane();
            if ( dane == null )
            {
                Console.WriteLine( "Blad danych wejsciowych" );
                return;
            }
            Console.WriteLine( "Dane wejsciowe wczytano poprawnie" );
            FileInfo file = new FileInfo( "wynik.txt" );
            TextWriter writer = file.CreateText();
            writer.WriteLine( "Zarzadzanie produkcja i uslugami - obliczanie cykli produkcyjnych" );
            writer.WriteLine( "---------" );
            writer.WriteLine( "Wczytane dane:" );
            ZapiszTablice( writer, dane );
            writer.WriteLine( "Cykl produkcyjny dla powyzszych danych wejsciowych wynosi " + ObliczCyklProdukcyjny( dane ) );
            writer.WriteLine( "---------" );
            MetodaKolejnychPar( writer, dane );
            writer.WriteLine( "---------" );
            MetodaGupty( writer, dane );
            writer.WriteLine( "---------" );
            MetodaPalmera( writer, dane );
            writer.WriteLine( "---------" );
            MetodaNEH( writer, dane );
            writer.WriteLine( "---------" );
            MetodaCDS( writer, dane );
            writer.WriteLine( "---------" );
            MetodaDannenbringa( writer, dane );
            Console.WriteLine("Wyniki zapisane do pliku wyniki.txt");
 
            writer.Close();
        }
 
        private static void MetodaDannenbringa( TextWriter writer, int[,] dane )
        {
            writer.WriteLine( "Metoda Dannenbringa" );
            writer.WriteLine();
            int[,] tab = new int[2, dane.GetUpperBound( 1 ) + 1];
            for ( int i = 0; i < dane.GetUpperBound( 1 ) + 1; i++ )
            {
                for ( int j = 0; j <= dane.GetUpperBound( 0 ); j++ )
                {
                    tab[0, i] += (dane.GetUpperBound( 0 ) + 2 - (j + 1)) * dane[j, i];
                }
            }
            for ( int i = 0; i < dane.GetUpperBound( 1 ) + 1; i++ )
            {
                for ( int j = 0; j <= dane.GetUpperBound( 0 ); j++ )
                {
                    tab[1, i] += (j + 1) * dane[j, i];
                }
            }
            ZapiszTablice( writer, tab );
            char[] sekwencja = MetodaJohnsona( tab );
            writer.WriteLine( "Optymalna sekwencja to " + new string( sekwencja ) );
            writer.WriteLine( "Dlugosc cyklu produkcyjnego wynosi " + ObliczCyklProdukcyjny( TworzTabliceDlaLiter( dane, sekwencja ) ) );
            Console.WriteLine("Metoda Dannenbringa... OK");
        }
 
        private static void MetodaCDS( TextWriter writer, int[,] dane )
        {
            writer.WriteLine( "Metoda CDS" );
            writer.WriteLine();
            int problemy = dane.GetUpperBound( 0 );
            writer.WriteLine( "Wygenerowano " + problemy + " sztucznych problemow" );
            List<Sekwencja> sekwencje = new List<Sekwencja>();
            for ( int i = 0; i < problemy; i++ )
            {
                writer.WriteLine( "#Problem K" + (i + 1) );
                int[,] tab = new int[2, dane.GetUpperBound( 1 ) + 1];
                for ( int j = 0; j < dane.GetUpperBound( 1 ) + 1; j++ )
                {
                    for ( int k = 0; k <= i; k++ )
                    {
                        tab[0, j] += dane[k, j];
                    }
                }
                for ( int j = 0; j < dane.GetUpperBound( 1 ) + 1; j++ )
                {
                    for ( int k = 0; k <= i; k++ )
                    {
                        tab[1, j] += dane[dane.GetUpperBound( 0 ) - k, j];
                    }
                }
                ZapiszTablice( writer, tab );
                Sekwencja sekwencja = new Sekwencja();
                sekwencja.lista.AddRange( MetodaJohnsona( tab ) );
                sekwencja.Cp = ObliczCyklProdukcyjny( TworzTabliceDlaLiter( dane, sekwencja.lista.ToArray() ) );
                writer.WriteLine( "Ustalona sekwencja to " + new string( sekwencja.lista.ToArray() ) );
                writer.WriteLine( "Dlugosc cyklu produkcyjnego dla tej sekwencji wynosi: " + sekwencja.Cp );
                writer.WriteLine();
                sekwencje.Add( sekwencja );
            }
            sekwencje.Sort( CiagRosnacy );
            writer.WriteLine( "Optymalna sekwencja to " + new string( sekwencje[0].lista.ToArray() ) );
            writer.WriteLine( "Dlugosc cyklu produkcyjnego dla tej sekwencji wynosi " + sekwencje[0].Cp );
            Console.WriteLine( "Metoda CDS... OK" );
        }
 
        private static char[] MetodaJohnsona( int[,] dane )
        {
            List<char> sekwencja_p = new List<char>(); //sekwencja poczatkowa
            List<char> sekwencja_k = new List<char>(); //sekwencja koncowa
            List<Para> lista = new List<Para>();
 
            for ( int i = 0; i <= dane.GetUpperBound( 1 ); i++ )
            {
                Para p = new Para( IndeksLitera( i ) );
                p.W2 = dane[0, i];
                p.W3 = dane[1, i];
                lista.Add( p );
            }
            int counter = lista.Count;
            for ( int i = 0; i < counter; i++ )
            {
                lista.Sort( CiagW2 );
                int min1 = lista[0].W2;
                lista.Sort( CiagW3 );
                int min2 = lista[0].W3;
                if ( min1 < min2 )
                {
                    lista.Sort( CiagW2 );
                    sekwencja_p.Add( lista[0].A );
                    lista.RemoveAt( 0 );
                }
                else
                {
                    sekwencja_k.Add( lista[0].A );
                    lista.RemoveAt( 0 );
                }
            }
            List<char> sekwencja = new List<char>();
            sekwencja.AddRange( sekwencja_p );
            sekwencja_k.Reverse();
            sekwencja.AddRange( sekwencja_k );
 
            return sekwencja.ToArray();
 
        }
 
        private static void MetodaNEH( TextWriter writer, int[,] dane )
        {
            writer.WriteLine( "Metoda NEH" );
            writer.WriteLine();
            List<Para> ws_sekwencja = new List<Para>();
            for ( int i = 0; i <= dane.GetUpperBound( 1 ); i++ )
            {
                ws_sekwencja.Add( new Para( IndeksLitera( i ) ) );
            }
            foreach ( Para para in ws_sekwencja )
            {
                for ( int i = 0; i <= dane.GetUpperBound( 0 ); i++ )
                {
                    para.W2 += dane[i, LiteraIndeks( para.A )];
                }
                writer.WriteLine( "Wspolczynnik " + para.A + ": " + para.W2 );
            }
            ws_sekwencja.Sort( CiagMalejacy );
            writer.Write( "Wstepna sekwencja to " );
            foreach ( Para para in ws_sekwencja )
            {
                writer.Write( para.A );
            }
            writer.WriteLine();
            List<char> sekwencja = new List<char>();
            sekwencja.Add( ws_sekwencja[0].A );
            writer.WriteLine( "Parametr " + ws_sekwencja[0].A + " rozpoczyna sprawdzanie sekwencji" );
            for ( int i = 0; i < ws_sekwencja.Count - 1; i++ )
            {
                List<Sekwencja> sekwencje = new List<Sekwencja>();
                for ( int j = 0; j < i + 2; j++ )
                {
                    Sekwencja s = new Sekwencja();
                    s.lista.AddRange( sekwencja );
                    s.lista.Insert( j, ws_sekwencja[i + 1].A );
                    s.Cp = ObliczCyklProdukcyjny( TworzTabliceDlaLiter( dane, s.lista.ToArray() ) );
                    sekwencje.Add( s );
                    writer.Write( "Ustalono sekwencje " );
                    foreach ( char c in s.lista.ToArray() )
                    {
                        writer.Write( c );
                    }
                    writer.WriteLine( " , obliczone Cp: " + s.Cp );
                }
                sekwencje.Sort( CiagRosnacy );
                sekwencja.Clear();
                sekwencja.AddRange( sekwencje[0].lista );
                writer.WriteLine( "#Wybrano optymalna sekwencje " + new string( sekwencje[0].lista.ToArray() ) + ", Cp rowne " + sekwencje[0].Cp );
            }
            writer.WriteLine();
            writer.WriteLine( "Koncowa sekwencja to " + new string( sekwencja.ToArray() ) );
            writer.WriteLine( "Cykl produkcyjny ma dlugosc " + ObliczCyklProdukcyjny( TworzTabliceDlaLiter( dane, sekwencja.ToArray() ) ) );
            writer.WriteLine();
            Console.WriteLine( "Metoda NEH... OK" );
        }
 
        private static void MetodaPalmera( TextWriter writer, int[,] dane )
        {
            writer.WriteLine( "Metoda Palmera" );
            writer.WriteLine();
            List<Para> sekwencja = new List<Para>();
            for ( int i = 0; i <= dane.GetUpperBound( 1 ); i++ )
            {
                sekwencja.Add( new Para( IndeksLitera( i ) ) );
            }
            foreach ( Para para in sekwencja )
            {
                for ( int i = 0; i <= dane.GetUpperBound( 0 ); i++ )
                {
                    para.W2 += (2 * (i + 1) - (dane.GetUpperBound( 0 ) + 2)) * dane[i, LiteraIndeks( para.A )];
                }
                writer.WriteLine( "Wspolczynnik " + para.A + " wynosi: " + para.W2 );
            }
            sekwencja.Sort( CiagMalejacy );
            writer.WriteLine();
            writer.Write( "Optymalna sekwencja to " );
            List<char> litery = new List<char>();
            foreach ( Para para in sekwencja )
            {
                writer.Write( para.A );
                litery.Add( para.A );
            }
            writer.WriteLine();
            writer.WriteLine( "Dlugosc cyklu produkcyjnego dla tej sekwencji wynosi " + ObliczCyklProdukcyjny( TworzTabliceDlaLiter( dane, litery.ToArray() ) ) );
            writer.WriteLine();
            Console.WriteLine( "Metoda Palmera... OK" );
        }
 
        private static void MetodaGupty( TextWriter writer, int[,] dane )
        {
            writer.WriteLine( "Metoda Gupty" );
            writer.WriteLine();
            List<Para> sekwencja = new List<Para>();
            for ( int i = 0; i <= dane.GetUpperBound( 1 ); i++ )
            {
                sekwencja.Add( new Para( IndeksLitera( i ) ) );
            }
            foreach ( Para para in sekwencja )
            {
                List<int> min = new List<int>();
                for ( int i = 0; i < dane.GetUpperBound( 0 ); i++ )
                {
                    min.Add( dane[i, LiteraIndeks( para.A )] + dane[i + 1, LiteraIndeks( para.A )] );
                }
                double licznik = dane[0, LiteraIndeks( para.A )] < dane[dane.GetUpperBound( 0 ), LiteraIndeks( para.A )] ? -1.0 : 1.0;
                para.W1 = licznik / Minimum( min.ToArray() );
                writer.WriteLine( "Wspolczynnik " + para.A + ": " + para.W1 );
            }
            sekwencja.Sort( CiagRosnacy );
            writer.WriteLine();
            writer.Write( "Optymalna sekwencja to " );
            List<char> litery = new List<char>();
            foreach ( Para para in sekwencja )
            {
                writer.Write( para.A );
                litery.Add( para.A );
            }
            writer.WriteLine();
            writer.WriteLine( "Dlugosc cyklu produkcyjnego dla tej sekwencji wynosi " + ObliczCyklProdukcyjny( TworzTabliceDlaLiter( dane, litery.ToArray() ) ) );
            writer.WriteLine();
            Console.WriteLine( "Metoda Gupty... OK" );
        }
 
        private static int CiagRosnacy( Para p1, Para p2 )
        {
            return p1.W1.CompareTo( p2.W1 );
        }
 
        private static int CiagRosnacy( Sekwencja s1, Sekwencja s2 )
        {
            return s1.Cp.CompareTo( s2.Cp );
        }
 
        private static int CiagMalejacy( Para p1, Para p2 )
        {
            return p2.W2.CompareTo( p1.W2 );
        }
 
        private static int CiagW2( Para p1, Para p2 )
        {
            return p1.W2.CompareTo( p2.W2 );
        }
 
        private static int CiagW3( Para p1, Para p2 )
        {
            return p1.W3.CompareTo( p2.W3 );
        }
 
        private static void MetodaKolejnychPar( TextWriter writer, int[,] dane )
        {
            writer.WriteLine( "Metoda Kolejnych Par" );
            writer.WriteLine();
            List<char> elementy = new List<char>();
            List<char> sekwencja = new List<char>();
            for ( int i = 0; i <= dane.GetUpperBound( 1 ); ++i )
            {
                elementy.Add( IndeksLitera( i ) );
            }
            int ilosc = 0;
            while ( elementy.Count > 1 )
            {
                writer.WriteLine( "Szukanie " + ++ilosc + " pary sekwencji" );
                List<Para> listaPar = new List<Para>();
                for ( int i = 0; i < elementy.Count; i++ )
                {
                    for ( int j = 0; j < elementy.Count; j++ )
                    {
                        if ( i != j )
                        {
                            listaPar.Add( new Para( elementy[i], elementy[j] ) );
                        }
                    }
                }
                Para minPara = listaPar[0];
                int minCp = ObliczCyklProdukcyjny( TworzTabliceDlaLiter( dane, new char[] { minPara.A, minPara.B } ) );
                foreach ( Para p in listaPar )
                {
                    int cp = ObliczCyklProdukcyjny( TworzTabliceDlaLiter( dane, new char[] { p.A, p.B } ) );
                    writer.WriteLine( "Obliczone Cp dla pary " + p + " wynosi: " + cp );
                    if ( cp < minCp )
                    {
                        minCp = cp;
                        minPara = p;
                    }
                }
                writer.WriteLine( "#Minimalne Cp wynosi " + minCp + " dla pary " + minPara );
                writer.WriteLine();
                sekwencja.Add( minPara.A );
                sekwencja.Add( minPara.B );
                elementy.Remove( minPara.A );
                elementy.Remove( minPara.B );
            }
            if ( elementy.Count > 0 )
            {
                foreach ( char c in elementy )
                {
                    sekwencja.Add( c );
                }
            }
            writer.Write( "Optymalna sekwencja to " );
            foreach ( char c in sekwencja )
            {
                writer.Write( c.ToString() );
            }
            writer.WriteLine();
 
            writer.WriteLine( "Dlugosc cyklu produkcyjnego dla tej sekwencji wynosi " + ObliczCyklProdukcyjny( TworzTabliceDlaLiter( dane, sekwencja.ToArray() ) ) );
            Console.WriteLine( "Metoda Kolejnych Par... OK" );
        }
 
        private static int[,] TworzTabliceDlaLiter( int[,] dane, params char[] litery )
        {
            int[,] tablica = new int[dane.GetUpperBound( 0 ) + 1, litery.Count()];
            for ( int j = 0; j < litery.Count(); j++ )
            {
                for ( int i = 0; i <= dane.GetUpperBound( 0 ); i++ )
                {
                    tablica[i, j] = dane[i, LiteraIndeks( litery[j] )];
                }
            }
            return tablica;
        }
 
        private static int ObliczCyklProdukcyjny( int[,] dane )
        {
            int w = dane.GetUpperBound( 0 ); //wiersze
            int k = dane.GetUpperBound( 1 ); //kolumny
            int[,] cykl = new int[w + 1, k + 1];
            cykl[0, 0] = dane[0, 0];
            for ( int i = 1; i <= w; ++i )
            {
                cykl[i, 0] = dane[i, 0] + cykl[i - 1, 0];
            }
            for ( int i = 1; i <= k; ++i )
            {
                cykl[0, i] = dane[0, i] + cykl[0, i - 1];
            }
            for ( int i = 1; i <= w; ++i )
            {
                for ( int j = 1; j <= k; ++j )
                {
                    if ( cykl[i - 1, j] > cykl[i, j - 1] )
                    {
                        cykl[i, j] = dane[i, j] + cykl[i - 1, j];
                    }
                    else
                    {
                        cykl[i, j] = dane[i, j] + cykl[i, j - 1];
                    }
                }
            }
            return cykl[w, k];
        }
 
        private static void ZapiszTablice( TextWriter writer, int[,] dane )
        {
            writer.WriteLine();
            for ( int i = 0; i <= dane.GetUpperBound( 1 ); ++i )
            {
                writer.Write( IndeksLitera( i ) + " " );
            }
            writer.WriteLine();
            for ( int i = 0; i <= dane.GetUpperBound( 0 ); ++i )
            {
                for ( int j = 0; j <= dane.GetUpperBound( 1 ); ++j )
                {
                    writer.Write( dane[i, j] + " " );
                }
                writer.WriteLine();
            }
            writer.WriteLine();
        }
 
        private static char IndeksLitera( int indeks )
        {
            return (char)(indeks + 65);
        }
 
        private static int LiteraIndeks( char litera )
        {
            return (int)(litera - 'A');
        }
 
        private static int Minimum( int[] dane )
        {
            int min = dane[0];
            for ( int i = 0; i < dane.Count(); i++ )
            {
                if ( dane[i] < min )
                {
                    min = dane[i];
                }
            }
            return min;
        }
 
        private static void WygenerujPusteDane()
        {
            Console.WriteLine();
            Console.Write( "Wprowadz liczbe wierszy: " );
            string line = Console.ReadLine();
            int wiersze = 0;
            if ( !String.IsNullOrEmpty( line ) )
            {
                try
                {
                    wiersze = Int32.Parse( line );
                }
                catch ( FormatException )
                {
                    Console.WriteLine( "Wprowadzono bledne dane" );
                    return;
                }
            }
            Console.WriteLine();
            Console.Write( "Wprowadz liczbe kolumn: " );
            line = Console.ReadLine();
            int kolumny = 0;
            if ( !String.IsNullOrEmpty( line ) )
            {
                try
                {
                    kolumny = Int32.Parse( line );
                }
                catch ( FormatException )
                {
                    Console.WriteLine( "Wprowadzono bledne dane" );
                    return;
                }
            }
            FileInfo fileInfo = new FileInfo( "dane.txt" );
            StreamWriter writer = fileInfo.CreateText();
            writer.WriteLine( String.Format( "{0} {1}", wiersze, kolumny ) );
            for ( int i = 0; i < wiersze; i++ )
            {
                for ( int j = 0; j < kolumny; j++ )
                {
                    writer.Write( "0 " );
                }
                writer.Write( writer.NewLine );
            }
            writer.Close();
            Console.WriteLine( "Utworzono pomyslnie przykladowy plik dane.txt" );
        }
 
        private static int[,] WczytajDane()
        {
            FileInfo fileInfo = new FileInfo( "dane.txt" );
            if ( !fileInfo.Exists )
            {
                Console.WriteLine( "Brak pliku z danymi" );
                return null;
            }
            StreamReader reader = fileInfo.OpenText();
            string line = reader.ReadLine();
            string[] lines = line.Split( ' ' );
            int wiersze = 0;
            try
            {
                wiersze = Int32.Parse( lines[0] );
            }
            catch ( FormatException )
            {
                Console.WriteLine( "Blad podczas odczytu pliku" );
                return null;
            }
            int kolumny = 0;
            try
            {
                kolumny = Int32.Parse( lines[1] );
            }
            catch ( FormatException )
            {
                Console.WriteLine( "Blad podczas odczytu pliku" );
                return null;
            }
            int[,] dane = new int[wiersze, kolumny];
            for ( int i = 0; i < wiersze; i++ )
            {
                line = reader.ReadLine();
                lines = line.Split( ' ' );
                for ( int j = 0; j < kolumny; j++ )
                {
                    try
                    {
                        dane[i, j] = Int32.Parse( lines[j] );
                    }
                    catch ( FormatException )
                    {
                        Console.WriteLine( "Blad podczas odczytu pliku" );
                        return null;
                    }
                }
            }
            return dane;
        }
    }
 
    public class Para
    {
        public char A;
        public char B;
 
        public double W1; //wspolczynniki do pomocy
        public int W2;
        public int W3;
 
        public Para( char A, char B )
        {
            this.A = A;
            this.B = B;
        }
 
        public Para( char A )
        {
            this.A = A;
        }
 
        public Para()
        {
        }
 
        public override string ToString()
        {
            return A.ToString() + B.ToString();
        }
    }
 
    public class Sekwencja
    {
        public List<char> lista;
        public int Cp;
 
        public Sekwencja()
        {
            lista = new List<char>();
        }
    }
}