This tests helped me to find bugs with wa5 and wa84

5 8
answer:
1
3
5 4 8
-----
5 18
answer:
1
3
5 6 18
-----
7 25
answer:
2
3
7 5 25

this is my code G++
#include<bits/stdc++.h>
using namespace std;

int n,k;


void pl(int a[],int b[],int c[])
{
  for(int i=1;i<=210;i++)
    {
    c[i]+=a[i]+b[i];
    c[i+1]+=c[i]/10;
    c[i]%=10;
  }
}

void cheng(int a[],int x)
{
  for(int i=1;i<=210;i++)
    {
    a[i]*=x;
    a[i]+=(a[i-1]/10);
    a[i-1]%=10;
  }
}

int f[2000][222];

int main()
{
    scanf("%d%d",&n,&k);
    f[0][0]=0;
    f[1][0]=1;
    f[1][1]=k-1;
    for(int i=2;i<=n;i++)
    {
        pl(f[i-2],f[i-1],f[i]);
         cheng(f[i],k-1);
    }
    for(int i=1;i<=210;i++)
    {
    f[n][i]+=f[n-1][i];
    f[n][i+1]+=f[n][i]/10;
    f[n][i]%=10;
  }
    int h=221;
    while(!f[n][h])    h--;
    for(int i=h;i>=1;i--)
        printf("%d",f[n][i]);
 return 0;
 }

I use "string ch" AC,but " char ch[maxn]" WA4,I don't know why .....

Test: ((**)*)
My answer is YES, but if we delete comment (**) it will remain only (*) and it must be arithmetic expr, but it's not cuz arithmetic expressions can't start with (*, so the right answer is NO, am I wrong?

Could you specify in the problem statement that the coordinates of the point in the last line are integer?

Also, could you specify the kind of precision near 10^{-14}? Is it absolute or relative?

New tests have been added to the problem which exploit a common mistake when using acos function. Hint: try to calculate acos(sqrt(3.0) * sqrt(3.0) - 4.0) in your programming language. 649 authors (60%) with accepted solutions have been challenged.

in this test Petr should go to 1 floor

create suffix links...

What is Test case #5 for question 1104

I wrote the code in python as below
x = input().split(' ')
a = int(x[0])
b = int(x[1])
sum = a + b
print(sum)

But it shows compilation error and I don't know what causes it and how to fix it.

#include <iostream>
#include <fstream>
#include <cstdio>
#include <cassert>
#include <complex>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <numeric>
#include <sstream>
#include <ctime>
#include <cctype>
#include <set>
#include <map>
#include <queue>
#include <bitset>
#include <deque>
#include <stack>
#include <memory.h>
using namespace std;
typedef long long ll;
#define mp make_pair
const int MAXN =1500;

struct bign
{
    int len, s[MAXN];
    bign ()
    {
        memset(s, 0, sizeof(s));
        len = 1;
    }
    bign (int num) { *this = num; }
    bign (const char *num) { *this = num; }
    bign operator = (const int num)
    {
        char s[MAXN];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }
    bign operator = (const char *num)
    {
        for(int i = 0; num[i] == '0'; num++) ;  //ȥǰµ¼0
        len = strlen(num);
        for(int i = 0; i < len; i++) s[i] = num[len-i-1] - '0';
        return *this;
    }
    bign operator + (const bign &b) const //+
    {
        bign c;
        c.len = 0;
        for(int i = 0, g = 0; g || i < max(len, b.len); i++)
        {
            int x = g;
            if(i < len) x += s[i];
            if(i < b.len) x += b.s[i];
            c.s[c.len++] = x % 10;
            g = x / 10;
        }
        return c;
    }
    bign operator += (const bign &b)
    {
        *this = *this + b;
        return *this;
    }
    void clean()
    {
        while(len > 1 && !s[len-1]) len--;
    }
    bign operator * (const bign &b) //*
    {
        bign c;
        c.len = len + b.len;
        for(int i = 0; i < len; i++)
        {
            for(int j = 0; j < b.len; j++)
            {
                c.s[i+j] += s[i] * b.s[j];
            }
        }
        for(int i = 0; i < c.len; i++)
        {
            c.s[i+1] += c.s[i]/10;
            c.s[i] %= 10;
        }
        c.clean();
        return c;
    }
    bign operator *= (const bign &b)
    {
        *this = *this * b;
        return *this;
    }
    bign operator - (const bign &b)
    {
        bign c;
        c.len = 0;
        for(int i = 0, g = 0; i < len; i++)
        {
            int x = s[i] - g;
            if(i < b.len) x -= b.s[i];
            if(x >= 0) g = 0;
            else
            {
                g = 1;
                x += 10;
            }
            c.s[c.len++] = x;
        }
        c.clean();
        return c;
    }
    bign operator -= (const bign &b)
    {
        *this = *this - b;
        return *this;
    }
    bign operator / (const bign &b)
    {
        bign c, f = 0;
        for(int i = len-1; i >= 0; i--)
        {
            f = f*10;
            f.s[0] = s[i];
            while(f >= b)
            {
                f -= b;
                c.s[i]++;
            }
        }
        c.len = len;
        c.clean();
        return c;
    }
    bign operator /= (const bign &b)
    {
        *this  = *this / b;
        return *this;
    }
    bign operator % (const bign &b)
    {
        bign r = *this / b;
        r = *this - r*b;
        return r;
    }
    bign operator %= (const bign &b)
    {
        *this = *this % b;
        return *this;
    }
    bool operator < (const bign &b)
    {
        if(len != b.len) return len < b.len;
        for(int i = len-1; i >= 0; i--)
        {
            if(s[i] != b.s[i]) return s[i] < b.s[i];
        }
        return false;
    }
    bool operator > (const bign &b)
    {
        if(len != b.len) return len > b.len;
        for(int i = len-1; i >= 0; i--)
        {
            if(s[i] != b.s[i]) return s[i] > b.s[i];
        }
        return false;
    }
    bool operator == (const bign &b)
    {
        return !(*this > b) && !(*this < b);
    }
    bool operator != (const bign &b)
    {
        return !(*this == b);
    }
    bool operator <= (const bign &b)
    {
        return *this < b || *this == b;
    }
    bool operator >= (const bign &b)
    {
        return *this > b || *this == b;
    }
    string str() const
    {
        string res = "";
        for(int i = 0; i < len; i++) res = char(s[i]+'0') + res;
        return res;
    }
};

istream& operator >> (istream &in, bign &x)
{
    string s;
    in >> s;
    x = s.c_str();
    return in;
}

ostream& operator << (ostream &out, const bign &x)
{
    out << x.str();
    return out;
}
bign dp[1800][2];
bign k;
int n;
int main()
{
    cin>>n>>k;
    dp[0][0]=k-1;
    dp[0][1]=0;
    for(int i=1;i<n;i++){
        dp[i][0]=(k-1)*(dp[i-1][0]+dp[i-1][1]);
        dp[i][1]=dp[i-1][0];
    }
    cout<<dp[n-1][0]+dp[n-1][1];
    return 0;
}

Please, somebody provide with test case ...

#include <stdio.h>
#include <math.h>

void recur(void);

int main() {

    recur();
    return 0;
}

void recur() {
    long int num;
    scanf("%ld", &num);
    if (num != EOF)
        recur();
    printf("%.5f\n", sqrt(num));
}

Edited by author 09.08.2018 18:20

char[200001] gives perfect time if you will check repeats while string is inputting

i used deque. cout got me TLE.using printf save me.

      if(st.front()!=s[i])
        {
            st.emplace_front(s[i]);
        }
        else
            st.pop_front();


for(it=st.end()-1; it>=st.begin(); it--)
    {
        printf("%c",*it);
    }

/*
* @Author: eleven
* @Date:   2017-05-21 02:50:38
* @Last Modified by:   eleven
* @Last Modified time: 2018-02-09 14:49:14
*/

// Status : AC ( works with stable_sort )
// doesn't works with sort

#include <bits/stdc++.h>

using namespace std;

#define SIZE 150005

struct team{
    int id;
    int solved;
}teams[SIZE];

bool foo(team lhs, team rhs){
return lhs.solved > rhs.solved;
}

void print(int n ){

    for(int i= 0; i<n ; ++i){
        cout<<teams[i].id<<" "<<teams[i].solved<<'\n';
    }
}


int main(){


    //freopen("in","r",stdin);
    //freopen("out","w",stdout);

    int n ;

    cin>>n;

    for(int i = 0; i<n ; ++i){
        cin>>teams[i].id>>teams[i].solved;
    }

    stable_sort(teams,teams+n ,foo);

    print(n);

    return 0;

}

#include<iostream>
#include<string>
#include<map>
#include<set>
using namespace std;

int main(){
    map<char,set<string>> dic;
    string w;
    int n;
    cin>>n;
    while(--n>=0){
        cin>>w;
        dic[w[0]].insert(w);
    }
    char c;
    cin>>c;
    for(auto s:dic[c])
        cout<<s<<endl;
}

If you are using DP, make sure you are using multimap instead of map ( In c++ )

Does anyon know, what is the longest test? I check a couple of numbers,with k= 99998 execution was the longest, but i'm not sure.

UPD: I check (write k=99998 instead a reading  number), and if WA#1 said truth, i reach the answere in 0,71. But this decision is still have TLE#41 :(

Maybe, there is a harder 'k' for this task?

Edited by author 07.08.2018 11:17

Edited by author 07.08.2018 11:17