ABC 354 (atcoder beginer 354) D、E、F

 

D

 

检查：

1. 有可能是推导式有问题，比如-/+写错

2. x,y A、B、C、D 顺序可能搞反了

不要盲目调试，先用人眼看一下代码的情况，找一下错误

 

很简单的找规律的题目。

很不能理解过的人，就这些。

x方向，y方向，都是4行/列，一个规律的循环。

 

求（0,0）到（x,y）中的黑色块：

第0-3行分别求出黑色块数目：通过列的循环

然后行的循环求和

 

 

cal(C,D) - cal(A,D) - cal(C,B) + cal(A,B) 这个很熟悉吧。就是：

 

为了方便求，先把x、y坐标的数值都转为正整数。

 

/*
检查；
1. 有可能是推导式有问题，比如-/+写错
2. x,y   A、B、C、D 顺序可能搞反了
不要盲目调试，先用人眼看一下代码的情况，找一下错误
*/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cstdbool>
#include <string>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <ctime>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <array>
#include <bitset>
using namespace std;
#define LL long long
#define ULL unsigned long long

const LL mod_1=1e9+7;
const LL mod_2=998244353;

const double eps_1=1e-5;
const double eps_2=1e-10;

const int maxn=2e5+10;

///x 0 to 4 : y value
LL f[4][4]={
{2,1,2,1},
{1,2,1,2},
{0,1,0,1},
{1,0,1,0}
};
LL f_loop[4]={6,6,2,2};

LL v[4];

LL cal(LL x, LL y)
{
    v[0]=v[1]=v[2]=v[3]=0;

    LL x_mod = x%4;
    LL y_mod = y%4;
    LL x_loop = x/4;
    LL y_loop = y/4;
    LL i,j,result=0;

    for (i=0;i<4;i++)
        v[i]+=y_loop * f_loop[i];
    for (i=0;i<4;i++)
    {
        for (j=0;j<y_mod;j++)
            v[i]+=f[i][j];
    }
    LL f_loop_cnt=v[0]+v[1]+v[2]+v[3];

    result += f_loop_cnt * x_loop;

    for (i=0;i<x_mod;i++)
        result+=v[i];


    return result;
}

int main()
{
    LL A,B,C,D,temp;

    if (0)
    {
        /*
        cout<<cal(1,1)<<endl;
        cout<<cal(2,2)<<endl;
        cout<<cal(3,3)<<endl;
        cout<<cal(4,4)<<endl;
        */

        //cout<<cal(1,2)<<endl;
        //cout<<cal(2,1)<<endl;

        //cout<<cal(1,6)<<endl;

        //cout<<cal(2,5)<<endl;

        cout<<cal(5,7)<<endl;
        cout<<cal(5,2)<<endl;
        cout<<cal(3,7)<<endl;
        cout<<cal(3,2)<<endl;


        return 0;
    }


    cin>>A>>B>>C>>D;

    if (A<0)
    {
        temp=(-A+4)/4;
        A+=temp*4;
        C+=temp*4;
    }

    if (B<0)
    {
        temp=(-B+4)/4;
        B+=temp*4;
        D+=temp*4;
    }





    cout<< cal(C,D) - cal(A,D) - cal(C,B) + cal(A,B);

    return 0;
}

 

 

 

E

这么多人对，有点怀疑是不是AI做的。

我用chatgpt 4-o（现在免费的），居然一发入魂，AC了。

我在CF提出了我的疑问。也看到有人跟我提出类似的疑问。

Panasonic Programming Contest 2024（AtCoder Beginner Contest 354） Announcement - Codeforces

So many people solve E in the competition. I doubt if some of them using chatgpt. I get AC of problem E using code generated by chatgpt 4o. The code is as follows.

It is more stranger that the people solve E are 2223, D are 2092. D、F are quite a lot easy compare with E. D is quite easy by the way, but only 2092 people solve it. I doubt if some of them using **chatgpt** by solving proble **E**. I get AC of problem E using code generated by chatgpt 4o.

 

 

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

struct Card {
    int front;
    int back;
};

int N;
vector<Card> cards;
unordered_map<int, bool> memo;

bool canWin(int state) {
    if (memo.count(state)) return memo[state];

    // Check all pairs of cards
    for (int i = 0; i < N; ++i) {
        if (!(state & (1 << i))) continue; // Card i is already removed
        for (int j = i + 1; j < N; ++j) {
            if (!(state & (1 << j))) continue; // Card j is already removed
            if (cards[i].front == cards[j].front || cards[i].back == cards[j].back) {
                int newState = state & ~(1 << i) & ~(1 << j);
                if (!canWin(newState)) {
                    memo[state] = true;
                    return true;
                }
            }
        }
    }
    memo[state] = false;
    return false;
}

int main() {
    cin >> N;
    cards.resize(N);
    for (int i = 0; i < N; ++i) {
        cin >> cards[i].front >> cards[i].back;
    }

    int initialState = (1 << N) - 1; // All cards are initially on the table
    if (canWin(initialState)) {
        cout << "Takahashi" << endl;
    } else {
        cout << "Aoki" << endl;
    }

    return 0;
}

 

 

=========================================================================

=========================================================================

=========================================================================

 

 

18这个数字，想到2^18（<1e6）复杂度？

 

 

 

 

F

看题/做题顺序：

a. E没有什么想法的话，这种题（如果）难做，而且时间耗在那，比如先做其它题目

b. 应该先看一下F题的题意的，也许比E好做呢？

c. 特别是1000人做对，就知道题目可能相对容易做，更加需要在第40分钟-第1小时的时候，花5分钟，看一下题意

d. 如果留30-40分钟做这道题，那么会很舒服，大概率能做出来。

 

从第1位置到第x位置递增，LIS的长度，从第n位置到第x位置递减，LIS的长度，相加，如果是对的，它就可以用

 

 

因为T<=2e5，a[i]<=1e9，LIS的树状数组写法应该是很不好写的。

那么用二分的写法。

善用lower_bound很重要。

对于反过来求从大到小的LIS，数值改为相反的负值就行了，即相当于求从小到大的LIS->代码设计上的巧妙。

 

这个例子，说明用lower_bound(>=)，而不是upper_bound(>)。

10
9
2 3 4 1 1 1 5 6 7

 

 

/*
题解：从第1位置到第x位置递增，LIS的长度，从第n位置到第x位置递减，LIS的长度，相加，如果是对的，它就可以用
*/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cstdbool>
#include <string>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <ctime>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <array>
#include <bitset>
using namespace std;
#define LL long long
#define ULL unsigned long long

const LL mod_1=1e9+7;
const LL mod_2=998244353;

const double eps_1=1e-5;
const double eps_2=1e-10;

const int maxn=2e5+10;

int a[maxn], f[maxn], pos1[maxn], pos2[maxn];
vector<int> vec;

int main()
{
    int T,n,m,cnt,u,i,j;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d",&n);
        for (i=0;i<n;i++)
            scanf("%d", &a[i]);

        m=0;
        for (i=0;i<n;i++)
        {
            j = lower_bound(f, f+m, a[i]) - f;

            pos1[i]=j;

            f[j] = a[i];
            if (j==m)
                m++;
        }

        /*
        for (i=0;i<n;i++)
            printf("%d ", pos1[i]);
        printf("\n");
        */


        for (i=0;i<n;i++)
            a[i]=-a[i];
        m=0;
        for (i=n-1;i>=0;i--)
        {
            j = lower_bound(f, f+m, a[i]) - f;

            pos2[i]=j;

            f[j] = a[i];
            if (j==m)
                m++;
        }


        u=0;
        for (i=0;i<n;i++)
            u = max(u, pos1[i]+pos2[i]);

        vec.clear();
        cnt=0;
        for (i=0;i<n;i++)
            if (pos1[i]+pos2[i]==u)
            {
                cnt++;
                vec.push_back(i);
            }

        printf("%d\n",cnt);
        for (i=0;i<cnt;i++)
        {
            printf("%d",vec[i]+1);
            if (i==cnt-1)
                printf("\n");
            else
                printf(" ");
        }


    }



    return 0;
}
/*
10
5
1 2 3 4 5
5
1 2 3 4 5
5
5 4 3 2 1
5
1 2 3 4 5
5
1 1 1 1 1
5
1 2 3 4 5



10
9
2 3 4 1 1 1 5 6 7
*/