#include <iostream>

using namespace std;
long long maxi,sum=1,sum1=1,n,a,b,i,v[100000],v1[100000];
int main()
{
    cin>>n>>a>>b;
    if(a>b)
        maxi=a;
    else
        maxi=b;
    v[maxi]=1;
    v1[maxi]=1;
    for(i=maxi+1;i<n+maxi;i++)
    {
        v[i]=sum1;
        v1[i]=sum;
        sum=sum+v[i]-v[i-a];
        sum1=sum1+v1[i]-v1[i-b];
    }
    cout<<sum+sum1;

    return 0;
}

What's this test??
My code:
#include <string>
#include <algorithm>
#include <iostream>
#define N 2222
#define MOD 1000000007ll

using namespace std;

long long f[N][N],d[N][N];
int n,m;
string s1,s2;

void init(){
    getline(cin,s1);
    getline(cin,s2);
    n=s1.length(),m=s2.length();
}

int main(){
    init();
    for (int i=0;i<=n;i++) d[i][0]=i;
    for (int i=0;i<=m;i++) d[0][i]=i;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (s1[i-1]==s2[j-1]) d[i][j]=d[i-1][j-1]+1;
            else d[i][j]=min(d[i-1][j],d[i][j-1])+1;
    for (int i=0;i<=n;i++) f[i][0]=1;
    for (int i=0;i<=m;i++) f[0][i]=1;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++){
            if (d[i][j]==i || d[i][j]==j) f[i][j]=1;
            else{
                if (s1[i-1]==s2[j-1]) f[i][j]=f[i-1][j-1];
                else f[i][j]=f[i-1][j]+f[i][j-1];
            }
            f[i][j]%=MOD;
        }
    cout<<f[n][m]<<endl;
}

If you get WA for the first test in C#

using System;
namespace Timus1104
{
    class Program
    {
        static void Main(string[] args)
        {
            var inputNumber = Console.ReadLine();
            Console.WriteLine("22");
        }
    }
}

just add return value

using System;
namespace Timus1104
{
    class Program
    {
        static int Main(string[] args)
        {
            var inputNumber = Console.ReadLine();
            Console.WriteLine("22");
            return 0;
        }
    }
}

dont use ',' use '.' at 4.5

I did it! I figured out this formula!

#include <string>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <math.h>
using namespace std;

int main()
{
    double n, t, s;
    cin >> n >> t >> s;
    double opposite[1000];
    for (int i = 0; i < n; i++)
    {
        cin >> opposite[i];
        if (opposite[i] >= s)
        {
            cout << fixed << setprecision(6) << ((opposite[i] + (s + t)) / 2) << endl;
        }
        else
        {
            cout << fixed << setprecision(6) << ((s + (opposite[i] + t)) / 2) << endl;
        }
    }

}

I think the promblem is in i-=2; This is to reduce i for ^Z symbol; idk how to fix this.



#include <iostream>
#include <algorithm>
#include <iomanip>
#include <math.h>
using namespace std;

int main()
{
    double num[1000];
    int i = 0;
    for (i; cin; i++)
    {
        cin >> num[i];

    }
    for (i-=2; i >= 0; i--)
    {

        cout << fixed << setprecision(4) << sqrt(num[i]) << endl;
    }
}

Does solution for (n,k) (19,18) exist?
I only find the answer for (21,18).
Do you guy have a better idea?

31
2 1
4 3
3 1
1 5
7 6
6 5
5 1
1 5
9 8
8 5
5 10
12 11
11 10
10 5
5 1
1 5
13 10
10 5
5 14
16 15
15 14
14 5
5 14
18 17
17 14
14 19
21 20
20 19
19 14
14 5
5 1

unable to understand first example. can anyone please kindly  explain.

o = 0
k = int(input())
a = [0] * (65536*2)
for i in range(k):
    a[int(input()) + 32768] = 1
h = int(input())
for i in range(h):
    if a[10000 - int(input()) + 32768] != 0:
        o += 1
if o >= 1:
    print('YES')
else:
    print('NO')

time limit exceed on python3
there a code:
a=[]
for i in range(int(input())):
    a.append(input())
b=[]
n=0
for j in range(int(input())):
    if input() in a:
        n+=1
print(n)

please help me

import sys
p = input()
p_list = []
for i in range(int(p)):
    x = input()
    p_list.append(x)
s = input()
s_list = []
for i in range(int(s)):
    x = input()
    s_list.append(x)

count = 0
l = set(s_list).intersection(p_list)

for i in l:
    count += s_list.count(i)

print (count)

a = input()

s = 0

ll = ['c','f','i','l','o','r','u','x','!']
hh = ['b','e','h','k','n','q','t','w','z',',']
pp = ['a','d','g','j','m','p','s','v','y','.',' ']

for i in range(len(a)):
    if a[i] in ll:
        s+=3
    elif a[i] in hh:
        s+=2
    elif a[i] in pp:
        s+=1
print(s)

Horner's method.

using System;

namespace Training
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] n = Console.ReadLine().Split(' ');
            int N = Convert.ToInt32(n[0]);
            int M = Convert.ToInt32(n[1]);
            double cnt = 1;
            int arr = 0;

            int[] ans = new int[M];
            double[] vs = new double[N];

            for (int i = 0; i < M; i++)
                ans[i] = Convert.ToInt32(Console.ReadLine());

            Array.Sort(ans);
            Array.Resize(ref ans, ans.Length+1);

            Console.WriteLine();

            for (int j = 0; j < M; j++)
            {
                if (ans[j] == ans[j + 1])
                    cnt++;
                else
                {
                    double x = Math.Round(cnt / M * 100, 2);
                    if ((int)x == x)
                        Console.WriteLine(x + ".00%");
                    else
                        Console.WriteLine(x + "%");
                    arr++;
                    cnt = 1;
                }
            }
            if (arr < N)
                for (int j = 0; j < N - arr; j++)
                    Console.WriteLine("0.00%");
        }
    }
}

Python 3
when counting by force I met TLE on the 45th test.
I printed out all the values of the function and saw that it is mirrored after 40 values.
f (40) = f (41)
f (39) = f (42)
...
f (2) = f (79)
therefore, counting only to 40, I got Accepted

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

const int maxn = 12;
const int maxst = 50000 + 5;

const int orz = 19260817;

struct Hash
{
    int cnt[orz];
    ull val[orz];
    int head[orz], nxt[orz], sz;

    void inline insert(ull u, int c)
    {
        int v = u % orz, i, lst = 0;
        for(i = head[v]; i; lst = i, i = nxt[i]) if(val[i] == u) break;
        if(i) cnt[i] = c;
        else {
            if(lst) nxt[lst] = ++sz;
            else head[v] = ++sz;
            val[sz] = u, cnt[sz] = c;
        }
    }

    int inline find(ull u)
    {
        int v = u % orz, i;
        for(i = head[v]; i; i = nxt[i]) if(val[i] == u) return cnt[i];
        return 0;
    }
} vti;
ull itv[maxst]; int tot;

int n, m;
char board[maxn + 3][maxn + 3];
int ptn[maxst][maxn + 2];
int fi, fj;

void inline getptn(int id)
{
    ull st = itv[id];
    int stk[maxn], cnt = 0;
    for(int i = 1; st; st >>= 2, ++i) {
        int p = st & 3;
        if(p == 1) stk[++cnt] = i;
        else  if(p == 2) ptn[id][i] = stk[cnt], ptn[id][stk[cnt--]] = i;
    }
}

void dfs(ull st, int dep, int k)
{
    if(dep > n + 1) {
        if(k) return;
        itv[++tot] = st;
        vti.insert(st, tot);
        return;
    }
    if(k > n + 1 - dep + 1) return;
    dfs(st, dep + 1, k); // #
    dfs(st | (1 << (2 * (dep - 1))), dep + 1, k + 1); // (
    if(k) dfs(st | (2 << (2 * (dep - 1))), dep + 1, k - 1); // )
}

void inline Init()
{
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= n; ++i) scanf("%s", board[i] + 1);
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= m; ++j)
            if(board[i][j] == '*') board[i][j] = 0;
            else board[i][j] = 1;
    dfs(0, 1, 0);
    for(int i = 1; i <= tot; ++i) getptn(i);
//    printf("tot = %d\n", tot);
    for(int i = n; i; --i) {
        for(int j = m; j; --j) {
            if(board[i][j]) {
                fi = i, fj = j;
//                printf("fi = %d, fj = %d\n", fi, fj);
                return;
            }
        }
    }
}

ll f[maxn + 2][maxn + 2][maxst];

ull inline fillas(ull S, int k, int c) {
    S &= ~(3 << (2 * (k - 1)));    // set zero
    S |= c << (2 * (k - 1));    // set c
    return S;
}

void inline Solve()
{
    f[0][m][vti.find(0)] = 1;
    for(int i = 0; i <= n; ++i) {
        for(int j = 1; j <= m; ++j) {
            for(int k = 1; k <= tot; ++k) {
                ull st = itv[k];
                if(!f[i][j][k]) continue;    // cut (=^o^=)
//                printf("f[%d][%d][%d] = %lld\n", i, j, k, f[i][j][k]);
                int tj = j + 1, ti = i; if(tj > m) tj = 1, ti = i + 1; // get target.

                int left = (st >> (2 * (tj - 1))) & 3;    // left plug
                int top = (st >> (2 * tj)) & 3;            // top plug
//                printf("[%d, %d] -> [%d, %d] with left = %d, top = %d.\n", i, j, ti, tj, left, top);

                if(!left && !top) {    // no plug
                    if(!board[ti][tj]) {    // if cannot
                        ull S = st;    // do nothing
                        if(tj == m) S = fillas(S, n + 1, 0), S <<= 2;
                        f[ti][tj][vti.find(S)] += f[i][j][k];
                    } else if(board[ti + 1][tj] && board[ti][tj + 1]) {    // can ?
                        ull S = fillas(fillas(st, tj, 1), tj + 1, 2); // fill it
                        if(tj == m) S = fillas(S, n + 1, 0), S <<= 2;
                        f[ti][tj][vti.find(S)] += f[i][j][k];
                    }
                }

                else if(left == 1 && top == 1) { // double left
                    int pp = ptn[k][tj + 1]; // get partner
                    ull S = fillas(fillas(fillas(st, tj, 0), tj + 1, 0), pp, 1);
                    if(tj == m) S = fillas(S, n + 1, 0), S <<= 2;
                    f[ti][tj][vti.find(S)] += f[i][j][k];
                }

                else if(left == 2 && top == 2) {    // double right
                    int pp = ptn[k][tj];    // get partner
                    ull S = fillas(fillas(fillas(st, tj, 0), tj + 1, 0), pp, 2);
                    if(tj == m) S = fillas(S, n + 1, 0), S <<= 2;
                    f[ti][tj][vti.find(S)] += f[i][j][k];
                }

                else if(left == 2 && top == 1) {    // right and left
                    ull S = fillas(fillas(st, tj, 0), tj + 1, 0);    // connect them directly
                    if(tj == m) S = fillas(S, n + 1, 0), S <<= 2;
                    f[ti][tj][vti.find(S)] += f[i][j][k];
                }

                else if(left == 1 && top == 2) {    // left and right
                    if(ti == fi && tj == fj) {    // end block only
                        ull S = fillas(fillas(st, tj, 0), tj + 1, 0);    // connect them directly
                        if(tj == m) S = fillas(S, n + 1, 0), S <<= 2;
                        f[ti][tj][vti.find(S)] += f[i][j][k];
                    }
                }

                else {    // one have plug but another no
//                    printf("ah?\n");
                    if(board[ti + 1][tj]) {    // if down can to
                        ull S = fillas(fillas(st, tj, left + top), tj + 1, 0);    // set
                        if(tj == m) S = fillas(S, n + 1, 0), S <<= 2;
//                        printf("%d %llu\n", vti.find(S), S);
                        f[ti][tj][vti.find(S)] += f[i][j][k];
                    }
                    if(board[ti][tj + 1]) {    // if right canto
                        ull S = fillas(fillas(st, tj, 0), tj + 1, left + top);    // set
                        if(tj == m) S = fillas(S, n + 1, 0), S <<= 2;
                        f[ti][tj][vti.find(S)] += f[i][j][k];
                    }
                }
            }
        }
    }
}

int main()
{
    Init();
/*    for(int i = 1; i <= tot; ++i) {
        printf("id: %d, st: %llu\n", i, itv[i]);
    }*/
    Solve();
    printf("%lld\n", f[n][m][1]);
    return 0;
}

Somebody had this test case?

Is there any algorithm to be applied except sorting?