Please help with wrong answer 7.
Possible input?

#include<stdio.h>
#include<math.h>
int main()
{
    unsigned long long int a[1000],i=0,b,c;
    double s;
    while(scanf("%llu",&b)!=EOF)
    {
        a[i]=b;
        i++;
        c=i;
    }
    for(i=c;i>=0;i--)
    {
        s=sqrt(a[i]);
        printf("%.4lf\n",s);
    }
    return 0;
}

Использую метод отжига и у меня ТЛ 16 тест, в кф проверил что у меня на макс тесте работает не более 2с. Возник вопрос, админы специально поставили такое ограничение чтобы метод отжига не проходил ?

#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <deque>
#include <queue>
#include <algorithm>
#include <iterator>
#include <bitset>
#include <iomanip>
#include <functional>
#include <list>
#include <cctype>
#include <array>
#include <algorithm>

using namespace std;
int main() {
    int n;
    n = 5;
    vector<vector<int>> vec(n);
    for (int i = 0; i < n; ++i) {
        vec[i].resize(n);
        for (int j = 0; j < n; j++)
        {
            cin >> vec[i][j];
        }
    }
    cout << min(min(min(vec[0][0] + vec[1][0] + vec[2][1] + vec[2][3] + vec[3][4],
                vec[0][0] + vec[3][0] + vec[2][3] + vec[1][2] + vec[1][4]),
                vec[0][0] + vec[0][2] + vec[1][2] + vec[1][3] + vec[3][4]),
                vec[0][0] + vec[0][2] + vec[2][3] + vec[1][3] + vec[1][4]) << endl;

    if (min(min(min(vec[0][0] + vec[1][0] + vec[2][1] + vec[2][3] + vec[3][4],
        vec[0][0] + vec[3][0] + vec[2][3] + vec[1][2] + vec[1][4]),
        vec[0][0] + vec[0][2] + vec[1][2] + vec[1][3] + vec[3][4]),
        vec[0][0] + vec[0][2] + vec[2][3] + vec[1][3] + vec[1][4]) ==
        vec[0][0] + vec[1][0] + vec[2][1] + vec[2][3] + vec[3][4])
    {
        cout << "1 2 3 4 5";
    }
    else if(min(min(min(vec[0][0] + vec[1][0] + vec[2][1] + vec[2][3] + vec[3][4],
        vec[0][0] + vec[3][0] + vec[2][3] + vec[1][2] + vec[1][4]),
        vec[0][0] + vec[0][2] + vec[1][2] + vec[1][3] + vec[3][4]),
        vec[0][0] + vec[0][2] + vec[2][3] + vec[1][3] + vec[1][4]) ==
        vec[0][0] + vec[3][0] + vec[2][3] + vec[1][2] + vec[1][4])
    {
        cout << "1 4 3 2 5";
    }
    else if (min(min(min(vec[0][0] + vec[1][0] + vec[2][1] + vec[2][3] + vec[3][4],
        vec[0][0] + vec[3][0] + vec[2][3] + vec[1][2] + vec[1][4]),
        vec[0][0] + vec[0][2] + vec[1][2] + vec[1][3] + vec[3][4]),
        vec[0][0] + vec[0][2] + vec[2][3] + vec[1][3] + vec[1][4]) ==
        vec[0][0] + vec[0][2] + vec[1][2] + vec[1][3] + vec[3][4])
    {
        cout << "1 3 2 4 5";
    }
    else {
        cout << "1 3 4 2 5";
    }
    cout << endl;
}

var n,k,ch,im:int64;
begin
read(n,k);
n:=n-1;
ch:=0;
im:=1;
while n>0 do begin
  if im<=k then begin
    n:=n-im;
    im:=im*2;
    ch:=ch+1;
    end;
  if im>k then begin
    n:=n-k;
    im:=im+k;
    ch:=ch+1;
    end;
  end;
writeln(ch);
end.

I hope these tests will be useful for you :)
4 5 0
3 4
1 2
3 1
2 4

and

7 7 0
1 2
1 3
2 4
2 5
3 6
3 7
4 7

The output must be 0 in both cases, but if you've done something wrong, it can be -1. Make sure your determination of connected components isn't wrong.

vector<vector<int64_t>> sequence = {
  {1,1,1,1,1,1,1,1,1,1,1,1},
  {1,0,2,0,4,0,8,0,16,0,32,0},
  {1,2,6,14,37,92,236,596,1517,3846,9770,24794}, // next is 62953
  {1,0,14,0,154,0,1696,0,18684,0,205832,0}, // next is 2267544
};

The solution is a linear recurrence. Output is multiplied by 2.

Edited by author 16.01.2020 16:32

I wrote a stupid solution and got wa32. Help please!

In my case this test may help you

16 19
1 2
2 3
3 4
4 5
5 1
1 6
6 7
7 8
8 9
9 10
10 6
5 11
11 12
12 13
13 4
3 14
14 15
15 16
16 2

The sequence of contraction affects the solution if you do not repeat the process after release the blossom.

if you contract (6,7,8,9,10), (4,5,11,12,13), (2,3,14,15,16) first
   you get maximum matching.
but if you contract (1,2,3,4,5) first and don't repeat the process after release it
   you don't get to the maximum.

Hope this helps.

Edited by author 13.01.2020 19:23

Edited by author 13.01.2020 19:23

import java.util.*;
public class LuckyNumber{
 public static void main(String args[]){
Scanner in = new Scanner(System.in);
int x = in.nextInt();
 int a1,a2,a3,b1,b2,b3;
a1 = x/100000; a2 = (x/10000)%10; a3 = (x/1000)%10;
b1 = (x/100)%10; b2 = (x/10)%10; b3 = x%10;
     if((a1+a2+a3) == (b1+b2+b3)) System.out.println("Lucky Number");
 else if(a1+a2+a3-(b1+b2+b3)>1 ||(b1+b2+b3)-(a1+a2+a3)>1) {
     System.out.println("prostoi bilet");
 }
else System.out.println("Lucky Number budet sleduwii ili prediduwi bilet");
     }
        }

Input:
2
2 1 2
2 1 2
My output: YES
Answer: NO

Rejudge pls!

On #1 test my program output:
4
4 5 1 6
with code: cout<<4<<endl<<4<<" "<<5<<" "<<1<<" "<<6
but get wrong answer. Why?

What is 5 test ?

if test 50000 300 300
My solution takes about 1.9 seconds (time library). the test fails.

almost all the time spent on summarizing lists:

"ncalls  tottime  percall  cumtime  percall filename:lineno(function)"
"99402    1.773    0.000    1.773    0.000  {built-in method builtins.sum}"

Maybe there is a way to more quickly summarize than the built-in function "sum"?

Edited by author 12.12.2019 15:42

Edited by author 12.12.2019 15:42

Edited by author 12.12.2019 15:42

What is WA11?
P.S. subfactorial func is correct
P.P.S. Admins, is it possible there are some bugs here?

Edited by author 29.02.2016 01:26

How can i fix WA18? Im solving using greedy algo

50

39
1 33 11 22 44 4 28 14 42 21 7 35 5 25 50 10 20 40 8 32 16 48 24 12 36 18 6 30 15 45 9 27 3 39 13 26 2 34 17


21

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