Rezultati

Up. imeNalogaJezikRezultatČas oddaje
lml-2018 Zaletavanje Java 0/100Napačen odgovor (WA) 19. apr '18 @ 20:04

Test Točke Porabljen spomin Porabljen čas Status
#1 0/14 32,633 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​8 7
8 4
4 7
2 7
8 3
Pravilen izhod:
​8 4
8 7
4 7
2 7
8 3
#2 14/14 32,984 MiB 0,000 s OK
#3 14/14 36,875 MiB 0,000 s OK
#4 0/14 39,742 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​15 30
20 16
18 30
20 1
20 14
3 30
17 30
1 30
1 30
20 28
Pravilen izhod:
​15 30
20 16
18 30
20 1
20 14
19 30
17 30
1 30
1 30
20 28
#5 0/14 40,176 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​100 47
63 100
100 84
100 90
100 82
100 56
100 33
100 59
27 100
100 28
Pravilen izhod:
​100 47
63 100
100 84
100 90
100 82
100 28
100 33
100 59
27 100
77 100
#6 15/15 37,340 MiB 0,000 s OK
#7 0/15 31,914 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​1000000000 520
1000000000 384
390 1000000000
1000000000 745
1000000000 332
Pravilen izhod:
​971 1000000000
1000000000 660
748 1000000000
403 1000000000
1000000000 531

Ocenjevani program (Avti.java):
import java.util.*;

public class Avti
{
    public static void main(String[]args)
    {
        Scanner skan = new Scanner(System.in);
        String s = skan.nextLine();
        String[] bla = s.split(" ");
        int n = Integer.parseInt(bla[0]);
        int w = Integer.parseInt(bla[1]);
        int h = Integer.parseInt(bla[2]);
        int[] izhodi = new int[n];
        int[] avti = new int[n];

        for(int i = 0; i < n; i++)
        {
            avti[i] = i;
        }

        int[] vsoteKoordinat = new int[n];
        int[][] koordinate = new int[n][3];
        int[] h_w = new int[n];

        for(int i = 0; i < n; i++)
        {
            s = skan.nextLine();
            bla = s.split(" ");
            int x = Integer.parseInt(bla[1]);
            int y = Integer.parseInt(bla[2]);
            koordinate[i][0] = x;
            koordinate[i][1] = y;
            vsoteKoordinat[i] = x + y;

            if(bla[0].equals("G"))
            {
                izhodi[i] = x;
                h_w[i] = h;
                koordinate[i][2] = 1;
            }
            else
            {
                izhodi[i] = w;
                h_w[i] = y;
                koordinate[i][2] = 0;
            }
        }

        sort(avti,vsoteKoordinat,0,n - 1);
        LinkedList<Integer> same = new LinkedList<Integer>();
        same.add(vsoteKoordinat[0]);

        for(int i = 1; i < n; i++)
        {
            if(vsoteKoordinat[i] == vsoteKoordinat[i - 1])
            {
                same.add(vsoteKoordinat[i]);
            }
            else
            {
                LinkedList<Integer> gor = new LinkedList<Integer>();
                LinkedList<Integer> desno = new LinkedList<Integer>();

                for(int j = 0; j < same.size(); j++)
                {
                    if(koordinate[avti[i - same.size() + j]][2] == 1)
                    {
                        gor.add(avti[i - same.size() + j]);
                    }
                    else
                    {
                        desno.add(avti[i - same.size() + j]);
                    }
                }

                LinkedList<Integer> differences = new LinkedList<Integer>();
                LinkedList<Integer> g = new LinkedList<Integer>();
                LinkedList<Integer> d = new LinkedList<Integer>();

                for(int j = 0; j < gor.size(); j++)
                {
                    for(int k = 0; k < desno.size(); k++)
                    {
                        int dif = koordinate[gor.get(j)][0] -koordinate[desno.get(k)][0];

                        if(dif > 0)
                        {
                            differences.add(dif);
                            g.add(gor.get(j));
                            d.add(desno.get(k));
                        }
                    }
                }

                for(int j = 0; j < differences.size(); j++)
                {
                    int temp = g.get(j);
                    g.set(j,d.get(j));
                    d.set(j,temp);
                    temp = izhodi[g.get(j)];
                    izhodi[g.get(j)] = izhodi[d.get(j)];
                    izhodi[d.get(j)] = temp;
                    temp = h_w[g.get(j)];
                    h_w[g.get(j)] = h_w[d.get(j)];
                    h_w[d.get(j)] = temp;
                }

                sort2(differences,g,d,0,differences.size() - 1);

                same.clear();
                same.add(vsoteKoordinat[i]);
            }
        }

        for(int i = 0; i < n; i++)
        {
            System.out.println(izhodi[i] + " " + h_w[i]);
        }
    }
    public static void sort(int[] izhodi, int[] vsoteKoordinat, int i, int j)
    {
        int start = i;
        int end = j;

        if(i >= j)
        {
            return;
        }

        while(i < j)
        {
            if(vsoteKoordinat[j] <= vsoteKoordinat[i])
            {
                int temp = vsoteKoordinat[i];
                vsoteKoordinat[i] = vsoteKoordinat[j - 1];
                vsoteKoordinat[j - 1] = vsoteKoordinat[j];
                vsoteKoordinat[j] = temp;
                temp = izhodi[i];
                izhodi[i] = izhodi[j - 1];
                izhodi[j - 1] = izhodi[j];
                izhodi[j] = temp;
                j--;
            }
            else
            {
                i++;
            }
        }

        sort(izhodi,vsoteKoordinat,start,i - 1);
        sort(izhodi,vsoteKoordinat,i + 1,end);
    }
    public static void sort2(LinkedList<Integer> differences, LinkedList<Integer> g, LinkedList<Integer> d ,int i, int j)
    {
        int start = i;
        int end = j;

        if(i >= j)
        {
            return;
        }

        while(i < j)
        {
            if(differences.get(j) < differences.get(i))
            {
                int temp = differences.get(i);
                differences.set(i,differences.get(j - 1));
                differences.set(j - 1,differences.get(j));
                differences.set(j,temp);
                temp = g.get(i);
                g.set(i,g.get(j - 1));
                g.set(j - 1,g.get(j));
                g.set(j,temp);
                temp = d.get(i);
                d.set(i,d.get(j - 1));
                d.set(j - 1,d.get(j));
                d.set(j,temp);
                j--;
            }
            else
            {
                i++;
            }
        }

        sort2(differences,g,d,start,i - 1);
        sort2(differences,g,d,i + 1,end);
    }
}