Incorrect Answer in Broken Necklace Problem USACO [closed]

Answer 1

This is a teaser! Every time solution is just so, so close! In the meantime the white beads are cause of black despair.

Here is the algorithm (I passed Usaco grader)
1) find first colored bead. say it is at position k in the n bead necklace
2) rearrange necklace: move the section 0-k to the end ,so it starts with true color. e.g {wwbrwbrb{ becomes {brwbrbww}
3) cut up the necklace into sub-sections (array of strings), so that each section starts with a color e.g. {b rw b r bww}
4) if first and last segment are the same color, join them
e.g. {b rw bw rw bww} becomes {bwwb rw bw rw} (sequence is preserved)
5) Notice!!!! the second last element (bw) ends with white. So white can be joined to rw that follows.
Also notice that following sequence will never starts with white.
6) for each entry in the array of sub sequences add lengths of entry k and k+1.
Then skim the white spaces (if any) from the entry k-1 and add to the above (since this is a circle then k-1 entry may be the last in the array).
if bigger than max then change max.

There is some tricky accounting for less than three sub sequences in the necklace but it is just tedious, no trick to it.

Answer 2

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

int main(){
    int numBeads;
    char temp1[705];
    char temp2[705];    

    int i,j,k,lim;

    int count1 = 0;
    int count2 = 0;
    int maxcount1 = 0;

    char virgin = ' ';
    bool flag = false; //flag == true if  virgin doesn't match

    FILE* fin  = fopen("beads.in","r");
    FILE* fout = fopen("beads.out","w");

    fscanf(fin,"%d",&numBeads);
    fscanf(fin,"%s",temp1);

    strcpy(temp2,temp1);
    strcat(temp1,temp2);

    for(i=0,j=numBeads-1;i<numBeads;i++,j++){
        count1 =0;
        count2 = 0;
        flag = false;
        virgin = ' ';
        for(k=i;flag==false && k < (i+numBeads);k++){
            if(temp1[k]=='w'){
                count1++;
            }
            else if(temp1[k]=='r'){
                if(virgin==' '){
                 virgin = 'r';               
                }
                if(virgin=='r')
                    count1++;
                else{
                    flag = true;        
                    k--;
                }
            }
            else if(temp1[k]=='b'){
                if(virgin==' '){
                 virgin = 'b';               
                }
                if(virgin=='b')
                    count1++;
                else{
                    flag = true;        
                    k--;
                }
            }
        }

        /* Block 2*/
        lim = k;
        flag = false;
        virgin = ' ';       
        for(k=j;flag==false && k < (j+numBeads) && k>=lim;k--){
            if(temp1[k]=='w'){
                count2++;
            }
            else if(temp1[k]=='r'){
                if(virgin==' '){
                 virgin = 'r';               
                }
                if(virgin=='r')
                    count2++;
                else{
                    flag = true;        
                    k--;
                }
            }
            else if(temp1[k]=='b'){
                if(virgin==' '){
                 virgin = 'b';               
                }
                if(virgin=='b')
                    count2++;
                else{
                    flag = true;        
                    k--;
                }
            }
        }
        if(maxcount1 < (count1+ count2))maxcount1 = count1 + count2;
    }

    fprintf(fout,"%d\n",maxcount1);
    return 0;
}

Answer 3

When you're presented with a weird problem in a computing contest, it's odds-on it'll be dynamic programming (the Bellman kind, not the Ruby kind.)

Have a look at this tutorial.

The basic idea of dynamic programming is to build up a "big" answer by answering small subproblems. My first intuitive thought is to think about longer and longer necklaces, starting with, like, one bead, but I'm honestly not particularly good at dynamic programming problems. (I've also noticed that the most common place to run into DP problems in the real world is in computing olympiads and problem sets in computer science classes.)

Answer 4

Here is my code:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;

/**
 *
 * @author Bansari
*/
public class beads {
    public static void main(String args[]){
    try{
        BufferedReader f = new BufferedReader(new FileReader("beads.in"));
                                                      // input file name goes above
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("str.txt")));
        int len = Integer.parseInt(f.readLine());
        String s=f.readLine();
        int c1=0,c2=0;
        int breakpoint=0;
        int max = 0;

        for(int i = 1;i<=len;i++){

            char before = s.charAt((i-1)%len);
            char after = s.charAt(i%len);

            if(before != after){
                c1=0;
                c2=0;
                int index = i-1;
                while(s.charAt(index)==before || s.charAt(index)=='w'){
                    char sc = s.charAt(index);
                    c1++;
                    if(index==0)
                        index = len-1;
                    else
                        index--;
                }
                index = i;
                while(s.charAt(index%len)==after || s.charAt(index%len)=='w'){
                    c2++;  
                    if(index == len-1)
                        index = 0;
                    else
                        index++;
                }
                if(max < (c1 + c2)){
                    breakpoint=i;
                    max = c1+c2;
                }
            }
        }
        out.println(max);
        out.close();
        System.exit(0);
        }catch(Exception e){

        }
    }
}

Answer 5

Heh, I'm up to this one but I haven't been bothered to code it up. Anyway, my ideas are this.

Firstly, you don't need to store all the bead colours (Go Australian spelling!), you just need to store how many beads of the same colour are in a row. So for:

RRBBBWRR

you just need to store:

2R 3B 1W 2R

One thing to note is if the ending and the starting beads are the same colour you have to account for that, so

RRBBBRR

should be stored as

4R 3B
or
3B 4R

Same thing. Note that the reason for this is not to save memory or anything, but to ensure that beads next to each other are different colours. We have done this by combining beads of the same colour.

Next is you go through each one:
- If it's red, you add up all the ones after that till you find a blue and then continue adding until you find another red
- If it's blue, do similarly except reversed
- If it's white, then the next bead will be red or blue. Do as above except with the number of white beads added

Here are some examples. The |'s mark where the sequence begins and ends.

B|RB|R

we find a R then a B then another R. Therefore we have to stop at the B. In

B|RWRB|R

We find an R and then another R but we haven't found a B yet so we continue. Then we find a B and then another R. This time, since we've found a B we have to stop.

B|RBW|R

we find a R then a B but we can continue since the next one is a W, then we find another R so we have to stop. In

B|WRBWB|R

we count the W then we find a R. Therefore we continue till we find a B and then continue till we find another R. This

B|WBRWR|B

is a reverse case.

Now all you have to do is implement it :D. Of course this doesn't take into account the actual number of beads in the the R, B and W and are just examples of single bead sequences. You will have to check all possible sequences. You also have to take care of the sequences which wrap around from the back to the start.

Lastly, you may notice that this algorithm is sometimes wasteful but N < 350 so even an O(N^3) should work in 1 second. Maybe 2. Anyway, I believe this is O(N^2) so you should be able to run this program 350 times in one second. Please comment if something's confusing because I'm not the best explainer. Happy coding.

Answer 6

I did this a long long time ago when I was learning programming. I just searched my computer and found the solution that I had submitted. I can provide the code but its all messed up . =P

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;






public class beads {

/**
 * @param args
 * @throws Exception 
 */
public static void main(String[] args) throws Exception {
    // TODO Auto-generated method stub
    new beads().go();
}

private void go() throws Exception {
    // TODO Auto-generated method stub
    BufferedReader bin = new BufferedReader(new FileReader("beads.in"));
    PrintWriter pout = new PrintWriter(new BufferedWriter(new FileWriter("beads.out")));

    int count = Integer.parseInt(bin.readLine());
    String beads = bin.readLine();
    int ans = compute(beads);

    pout.println(ans);
    pout.close();
}

private int compute(String beads) {
    // TODO Auto-generated method stub
    int length = beads.length();
    int maxbeads = 0;
    for(int i = 0; i < length; i++){
        int left = 0;
        int right = 0;
        left = computeLeft(beads,i);
        if(left == length){ maxbeads = left; break;}
        right = computeRigtht(beads,i);
        if(right == length){ maxbeads = right; break;}
        if((left+right) > maxbeads) maxbeads = left+right;
        if(maxbeads == length) break;


    }           
    return maxbeads;
}

private int computeLeft(String beads, int i) {
    // TODO Auto-generated method stub
    int l = beads.length();

    int j = i;
    int count = 0;
    char ch = beads.charAt(i);
    for(; j >=0; j--){
        if(ch == 'w'){//Didnt notice this kind of case before
            ch = beads.charAt(j);
            count++;
        }
        else if(beads.charAt(j) == ch || beads.charAt(j)== 'w'){
            count++;
        }
        else break;
    }
    if(j < 0) j = l-1;
    for(; j > i; j--){
        if(beads.charAt(j) == ch || beads.charAt(j)== 'w'){
            count++;
        }
        else break;
    }

    return count;
}

private int computeRigtht(String beads, int i) {
    // TODO Auto-generated method stub
    int l = beads.length();
    int j = 0;
    if(i == l-1) j = 0;
    else j = i+1;
    int k = j;
    int count = 0;
    int ch = beads.charAt(j);
    for(; j <l; j++){
        if(ch == 'w'){
            ch = beads.charAt(j);
            count++;
        }
        else if(beads.charAt(j)== ch || beads.charAt(j)=='w'){
            count++;
        }
        else break;
    }
    if(j == l) j = 0;
    for(; j < k-1; j++){
        if(beads.charAt(j) == ch || beads.charAt(j)== 'w'){
            count++;
        }
        else break;
    }


    return count;
}

}