Incorrect Answer in Broken Necklace Problem USACO [closed]

Answer 1

Its an old thread, but might be useful to people learning programming. Here is a simple solution using brute force. The idea is that we make one pass through the data to count colours. In the second loop we perform pairwise comparison of sums from the left and the right part. Code should be easy to follow:

import java.io.*;
import java.util.LinkedList;
import java.util.List;
import java.util.TreeSet;

public class beads {

    public static void main(String[] args) throws IOException {
        BufferedReader f = new BufferedReader(new FileReader("beads.in"));
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("beads.out")));
        f.readLine();//length
        String s1 = f.readLine();
        List<String> counts = new LinkedList<String>();
        char[] colors = (s1.concat(s1)).toCharArray();
        char previousColor = ' ';
        int count = 0;
        for (char color : colors) {
            if (previousColor != color && count > 0) {
                counts.add(count + "-" + previousColor);
                count = 0;
            }
            count++;
            previousColor = color;
        }

        if (counts.isEmpty()) {//special case when there is only one color
            out.println(count/2);
            out.close();
            System.exit(0);
        }
        TreeSet<Integer> result = new TreeSet<Integer>();
        for (int i = 1; i < counts.size(); i++) {
            if(counts.get(i).split("-")[1].charAt(0)=='w')continue;
            int left = getLeft(counts, i);
            int right = getRight(counts, i);
            result.add((left+right));
        }
        out.println(result.last());
        out.close();
        System.exit(0);
    }

    private static int getLeft(List<String> counts, int i) {
        char start = counts.get(i - 1).split("-")[1].charAt(0);
        boolean doContinue = true;
        int count = 0;
        while (doContinue) {
            String[] s = counts.get(--i).split("-");
            char color=s[1].charAt(0);
            if(start=='w' && color!='w')start=color;
            boolean incr = (color == 'w' || color==start);
            if(incr)
                count += Integer.parseInt(s[0]);
            else doContinue=false;

            doContinue = doContinue && i > 0;
        }
        return count;
    }


    private static int getRight(List<String> counts, int i) {
        char start = counts.get(i).split("-")[1].charAt(0);
        boolean doContinue = true;
        int count = 0;
        while (doContinue) {
            String[] s = counts.get(i).split("-");
            char color=s[1].charAt(0);
            if(start=='w' && color!='w')start=color;

            boolean incr = (color == 'w' || color == start);
            if(incr)
                count += Integer.parseInt(s[0]);
            else doContinue=false;

            doContinue = doContinue && ++i < counts.size()-1;
        }
        return count;
    }
}

Answer 2

I used quasiverse's algo and solved it. The USACO server is down and I am not able to test it on their judge, but I think I have solved it.

 #include<iostream>
 #include<fstream>
 #include<string>
 #include<cstring>
 #include<cstdlib>

 #define MAXLEN 350

 using namespace std;



 ofstream fout ("beads.out");


 typedef struct node
 {
     char color;
     int times;
     int lenMax;
     struct node* next;
 } nodeList;

 nodeList * getnode()
 {
     nodeList* temp=(nodeList*) malloc (sizeof(nodeList));
     temp->next=NULL;
     temp->lenMax=0;
     return temp;
 }



 void append(nodeList **head,char  tColor,int m)
 {
     nodeList *p=NULL,*newNode=NULL;
     newNode =getnode();
     newNode->color=tColor;
     newNode->times=m;
     newNode->lenMax=0;
     if(*head==NULL)
     {
         *head=newNode;
         return;
     }

     p=*head;

     while(p->next)
         p=p->next;

     p->next=newNode;

 }

 void shiftNodes(nodeList **head)
 {
     int mon=0;
     nodeList *last=NULL,*p=NULL,*t=NULL;

     p=*head;
     do
     {
         //cout<<p->color<<" "<<p->times<<endl;
         last=p;
         p=p->next;
     }
     while(p!=NULL);
     p=*head;
     last->next=*head;

     t=*head;
     do
     {
         if(((*head)->color=='w' || (last)->color=='w' ) || (*head)->color==last->color)
         {
             (*head)=(*head)->next;
             last=last->next;
         }
         else if((*head)->color!=last->color )
         {
             break;
         }
         p=p->next;
     }
     while(p!=t);

 }
 void computeLenMaxB(nodeList ** head)
 {
     nodeList *p =NULL,*t=NULL,*s=NULL;
     t=p=*head;

     bool gotR=false;
     int tempLenMax=0;
     do
     {
         if(p->color=='b' && gotR){
             break;
         }
         else if(p->color=='b' && !gotR){
             tempLenMax+=p->times;
         }

         else if(p->color=='r' && !gotR){
             tempLenMax+=p->times;
             gotR=true;
         }
         else if(p->color=='r' && gotR){
             tempLenMax+=p->times;
         }
          else if(p->color=='w' ){
             tempLenMax+=p->times;
         }


         p=p->next;
     }
     while(p!=t);
     (*head)->lenMax=tempLenMax;
 }

 void computeLenMaxR(nodeList ** head)
 {
     nodeList *p =NULL,*t=NULL,*s=NULL;
     t=p=*head;
     bool gotR=false;
     int tempLenMax=0;
     do
     {
         if(p->color=='r' && gotR){
             break;
         }
         else if(p->color=='r' && !gotR){
             tempLenMax+=p->times;
         }

         else if(p->color=='b' && !gotR){
             tempLenMax+=p->times;
             gotR=true;
         }
         else if(p->color=='b' && gotR){
             tempLenMax+=p->times;
         }
          else if(p->color=='w' ){
             tempLenMax+=p->times;
         }


         p=p->next;
     }
     while(p!=t);
     (*head)->lenMax=tempLenMax;
 }


 void fillLenMax(nodeList ** head)
 {
     nodeList *p =NULL,*t=NULL,*s=NULL;
     t=p=*head;
     int wBeads=0;
     do
     {
         s=p;
         if(p->color=='b')
         {
             computeLenMaxB(&p);
         }
          else  if(p->color=='r')
          {
              computeLenMaxR(&p);
          }

          else  if(p->color=='w')
          {
              if(p->next->color=='b'){
                 computeLenMaxB(&p);
              }
              else if(p->next->color=='r'){
                 computeLenMaxR(&p);
              }
          }
         p=p->next;
     }
     while(p!=t);


 }

 int calcMaxLenMax(nodeList *head)
 {
     nodeList *p=NULL;
     p=head;
     int max=0;
     do
     {
         //fout<<p->color<<" "<<p->times<<" "<<p->lenMax<<endl;
         max=(max>p->lenMax)?max:p->lenMax;
         p=p->next;
     }
     while(p!=head);
     return max;
 }

 int main()
 {
     ifstream fin ("beads.in");

     char  necklace[MAXLEN];
     int i,j,max;

     fin>>necklace;

     nodeList* list=NULL;
     int repeat = 0;
     i=0;
     while(i<strlen(necklace))
     {
         repeat = 0;
         for(j=i; necklace[j]==necklace[i]; j++)
         {
             repeat++;
         }

         append(&list ,necklace[i],repeat);
         i=i+repeat;

     }

     shiftNodes(&list);

     fillLenMax(&list);

     max=calcMaxLenMax(list);

     fout<<max<<endl;

     return 0;


 }

Answer 3

RETRACTED -- THIS IS WRONG because it does not consider white beads.

i can either see a simpler than the accepted answer, or the explanation is too complex. here's the algorithm in pseudocode (ignoring the case of all same color):

p = position of first bead of different color than bead 0
create array of run-lengths: r={5,15,2,9,13}
create array of sums of adjacents s={20,17,11,22,18} (wrap last)
find index, k, in s[] of max sum: here it is s[3]
position = p + r[0] + r[1] + ... + r[k]