If you got WA #3, check case n=1 ;)

input:

HELLO. I AM ANJELA! AND YOU?
I AM BLONDE.


output:

Hello. I am anjela! And you?
I am blonde.

Give me test . please!

I can't get past WA #5.  I know it's an n=500 case, but my solution works for n=500 with various k and passenger data as far as I can tell.   Any other boundary conditions known to be in test 5?

P and A must satisfy the condition :

P ( P + 2A - 1) = 2N

good luck !

Test
0 0 0 0 0 1
499

Answer
10
1 2 3 4 5 6 7 8 9 10

I am not getting how my program is giving wrong answer for some test case#12.
Can someone help pls

[code deleted]

Edited by author 21.06.2013 16:13

Edited by moderator 21.10.2013 20:39

use operator SEEKEOF

while seekeof do
begin
 read(x);
 .....
 .....
end;

package problemsPackage;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class IsenbayevNumbers {
    public static void main(String args[]) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

        int numberOfTeams = Integer.parseInt(in.readLine());

        // Node containing Names of progers in team
        LinkedList<String[]> teamsList = new LinkedList<String[]>();

        LinkedList<String> uniqueParticipantsName = new LinkedList<String>();

        while (numberOfTeams != 0) {
            StringTokenizer tokenizer = new StringTokenizer(in.readLine(), " ");
            String members[] = new String[3];
            int i = 0;
            while (tokenizer.hasMoreTokens()) {
                members[i] = tokenizer.nextToken();
                addToList(uniqueParticipantsName, members[i]);
                i++;
            }
            teamsList.add(members);
            numberOfTeams--;
        }
        int array[][] = new int[uniqueParticipantsName.size()][uniqueParticipantsName.size()];
        fillArray(array,uniqueParticipantsName,teamsList);
        int participants = uniqueParticipantsName.size();
        int esenId = getIndex("Isenbaev", uniqueParticipantsName);

        int[] tentativeDistances = new int[participants];
        LinkedList<Integer>unvisitedNodes = new LinkedList<Integer>();

        for(int i=0;i<participants;i++){
            unvisitedNodes.add(i);
            if(i==esenId) tentativeDistances[i]=0;
            else tentativeDistances[i]=4000;
        }

        while(unvisitedNodes.size()!=0){
            int node  = getCurrentNode(tentativeDistances,unvisitedNodes);
            processNode(node,tentativeDistances,unvisitedNodes,array);
        }
        String names[] = new String[uniqueParticipantsName.size()];
        for(int i=0;i<uniqueParticipantsName.size();i++){
            names[i]=uniqueParticipantsName.get(i);
        }

        java.util.Arrays.sort(names);

        for(int i=0;i<names.length;i++){
            int index = getIndex(names[i], uniqueParticipantsName);
            int distance = tentativeDistances[index];
            if(distance!=4000)
                System.out.print(names[i]+" "+distance+"\n");
            else System.out.print(names[i]+" undefined\n");
        }
    }







    private static void processNode(int node, int[] tentativeDistances,
            LinkedList<Integer> unvisitedNodes, int[][] array) {

            LinkedList<Integer>neighbors = new LinkedList<Integer>();
            for(int j=0;j<array.length;j++){
                if(node!=j)
                    if(array[node][j]==1) neighbors.add(j);
            }

            for(int i=0;i<neighbors.size();i++){
                if(tentativeDistances[neighbors.get(i)]>tentativeDistances[node]+1)
                    tentativeDistances[neighbors.get(i)]=tentativeDistances[node]+1;
            }

            for(int i=0;i<unvisitedNodes.size();i++){
                if(unvisitedNodes.get(i)==node){
                    unvisitedNodes.remove(i);
                    break;
                }
            }
    }







    private static int getCurrentNode(int[] tentativeDistances,
            LinkedList<Integer> unvisitedNodes) {
        int minimum=10000;
        int index=0;
        for(int i=0;i<unvisitedNodes.size();i++){
            if(tentativeDistances[unvisitedNodes.get(i)]<minimum){
                minimum=tentativeDistances[unvisitedNodes.get(i)];
                index=unvisitedNodes.get(i);
            }
        }
        return index;
    }



    /**
     * Fill twodimensional array
     * @param array
     * @param uniqueParticipantsName
     * @param teamsList
     */
    private static void fillArray(int[][] array,
            LinkedList<String> uniqueParticipantsName,
            LinkedList<String[]> teamsList) {
        for(int i=0;i<uniqueParticipantsName.size();i++){
            String name = uniqueParticipantsName.get(i);
            for(int j=0;j<teamsList.size();j++){
                boolean exist=false;
                if(teamsList.get(j)[0].equalsIgnoreCase(name) || teamsList.get(j)[1].equalsIgnoreCase(name) || teamsList.get(j)[2].equalsIgnoreCase(name)) exist=true;
                if(exist){
                    if(!teamsList.get(j)[0].equalsIgnoreCase(name)) array[getIndex(name, uniqueParticipantsName)][getIndex(teamsList.get(j)[0], uniqueParticipantsName)]=1;
                    if(!teamsList.get(j)[1].equalsIgnoreCase(name)) array[getIndex(name, uniqueParticipantsName)][getIndex(teamsList.get(j)[1], uniqueParticipantsName)]=1;
                    if(!teamsList.get(j)[2].equalsIgnoreCase(name))    array[getIndex(name, uniqueParticipantsName)][getIndex(teamsList.get(j)[2], uniqueParticipantsName)]=1;
                }
            }
        }
    }


    /**
     * Index of name in list.
     * @param name
     * @param uniqueParticipantsName
     * @return
     */
    private static int getIndex(String name,LinkedList<String> uniqueParticipantsName){
        int index=0;
        for(int i=0;i<uniqueParticipantsName.size();i++){
            if(uniqueParticipantsName.get(i).equalsIgnoreCase(name)){
                index=i;
                break;
            }
        }
        return index;
    }


    /**
     * Store unique participant names into list
     * @param uniqueParticipantsName
     * @param string
     */
    private static void addToList(LinkedList<String> uniqueParticipantsName,
            String string) {
        boolean exist = false;
        for (int i = 0; i < uniqueParticipantsName.size(); i++) {
            if (uniqueParticipantsName.get(i).equalsIgnoreCase(string)) {
                exist = true;
                break;
            }
        }
        if (!exist)
            uniqueParticipantsName.add(string);
    }

}

Any suggestions please?
I'm a complete newbie at graph theory, so I guess this is something really stupid.

just change char mas_n[200000]={0};
into char mas_n[200005]={0};

))

Edited by author 26.07.2012 18:28

?

Edited by author 10.05.2012 01:08

Somebody.... Anybody... Help

My solution is very simple. All weight of edges are inverted((a)->(-a)). Ford-Bellman!

#include <iostream>
//where is my mistake?
using namespace std;

int main()
{
    int number, result;
    cout << "Enter number: " << endl;
    cin >> number;
    result = number;
    if (number > 0 && number <= 10000)
    {
        for (int i = 1; i<number; i++)
        {
            result = result + i;
        }
    }

    else if (number <= 0 && number >= -10000)
    {
        for (int j = 1; j > number; j--)
        {
            result = result + j;
        }
    }
    else
    {
        cout << "Enter the number within the limits of [-10000;10000]" << endl;
        return main();
    }
    cout << "Otvet: " << result << endl;
    return 0;
}

#include<iostream>
using namespace std;
int x=1;
int recursive(int n)
{
    if(n==0)
        return 0;
    if(n==1)
        return n;
    if((n%2)==0)
        recursive(n/2);
    else if(n>2 )
    {
        if(n%2)
        {
        recursive(n/2);
        return 1+recursive((n/2)+1);
        }

    }
    return x;
}

int maxi(int input)
{
    int temp,result=0;
    for(int i=0;i<=input;i++)
    {
        temp=recursive(i);
        if(result<temp)
        {
            result=temp;
        }
    }
    return result;
}
int main(void)
{
    int result,input=-1;
    while(1)
    {
        cin>>input;
        if(input==0) break;
        result=maxi(input);
        cout<<result<<endl;
    }
    return 0;
}

var i,n,k,m,j,MaxSum,t:word;
    s,c:longint;
function Dig_sum(x:word):word;
var res:word;
begin
  res:=0;
  while (x>0) do
   begin
     res:=res+(x mod 10);
     x:=x div 10
   end;
  Dig_sum:=res;
end;
begin
 readln(n);
 k:=1; t:=(n div 2);
 for i:=1 to t do k:=k*10; dec(k);
 MaxSum:=9*t;
 s:=0;
 for i:=0 to MaxSum do
  begin
    c:=0;
    for j:=0 to k do
           begin
             if Dig_sum(j)=i then inc(c);
           end;
    s:=s+c*c;
  end;
 if (n mod 2)=1 then s:=s*10;
 writeln(s);
 {Ukraine,Khmelnitsky State University}
end.

Edited by author 27.07.2004 21:14

My solution uses binary search to find such height for second lamp that garland is never under the floor and this height is the lowest possible. For checking that garland is never under the floor I use simple O(N).