前言

這屆題總體偏思維化，碼量不大，這屆題還是十分友善的。

[CSP-J2020] 優秀的拆分

題目大致意思是說給定一個正整數N，讓你用二進位制表示(但不包括2的0次方），又因為我們可以證明二進位制可以表示任何整數，所以在題目中，只要是偶數，就是“優秀的拆分”，因此，如果N為奇數，就可以直接排除，即輸出-1。
接著我們來看N為偶數的情況，由於二進位制有其專有的特性，就是說如果能取大的，就儘量取大的，因此我們只需要從最大的二的正整數冪找起，然後一次次除以二，一直除到二時，就可以結束。
於是我們用 \(a_i\)來表示二的i次冪，所以只要用bool型來存即可。

#include<bits/stdc++.h>
using namespace std;
const int maxn=100005;
int n;
long long now=1;  
bool a[10005];
int main()
{
	cin>>n;
	if(n%2){
		cout<<-1<<endl;
		return 0;
	} 
	int i=0; 
	while(now*2<=n){
		now*=2;
		i++;
	} 
	int i1=i; 
	while(now>1){
		if (n-now>=0){
			a[i1]=1;
			n-=now;
		}
		i1--;
		now/=2;
	}  
	for(register int j=i;j>=1;--j){
		if(a[j]==0) continue;
		long long ans=pow(2,j);
		printf("%lld ",ans);
	} 
	return 0; 
}
 

[CSP-J2020] 直播獲獎

一道簡單的排序題，思路非常簡單，不超時（前提C++）。

#include<bits/stdc++.h>
using namespace std;
int t[10005];
int n,w;
int main()
{
	int x;
	cin>>n>>w;
	for(int i=1;i<=n;i++)
	{
		cin>>x;
		t[x]++;
		int sum=0;
		for(int j=600;j>=0;j--)
		{
			sum+=t[j];
			if(sum>=max(1,i*w/100))
			{
				cout<<j<<' ';
				break;
			}
		}
	}
	return 0;
 }
 

[CSP-J2020] 表示式

這屆入門組最難的題，有必要多說兩句。

這是一道模擬+二叉樹。

首先輸入的一坨字串要先解析，利用棧來建表示式樹，這就是一個小模擬，相信正常人都會吧。

對於非運算，我直接用德·摩根定律，下傳標記讓子樹資訊都反一下。（其實沒必要，當初這樣寫是因為覺得每個結點都二叉比較美，方便後續處理）

題目裡有個資訊是“每個變數在表示式中出現恰好一次”，而每個詢問只改變一個變數的值，這對原答案來說就產生兩個可能：變或不變。這聽起來是一句廢話，其實蘊含的意思是：有些變數對整個表示式其決定作用，其改變則原答案也改變；有些變數對整個表示式根本沒用，其變不變原答案都不變。

說明白一點，就是1 & x = x ，0 | x= x

那我們就給樹上每個結點建一個廢物標記，對& 來說，如果一棵子樹是 0，那另外一棵子樹內所有葉結點都應該打上廢物標記，對|同理。

先計算出原表示答案ans，這樣我們在查詢的時候，沒被標記的就說明它往上到根節點都不存在一種讓它變成廢物的運算，所以答案是!ans，如果有標記則答案依舊為ans。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF = 0x3f3f3f3f;
const LL mod = 1e9 + 7;
const int N = 1000005;

char s[N];
int a[N];
int son[N][2], ck;
int flag[N], c[N];
int n, q;
int dfs(int u, int g) {
    a[u] ^= g;
    if (u <= n) {
        return a[u];
    }
    int x = dfs(son[u][0], g ^ flag[son[u][0]]);
    int y = dfs(son[u][1], g ^ flag[son[u][1]]);
    if (a[u] == 2) {
        if (x == 0) c[son[u][1]] = 1;
        if (y == 0) c[son[u][0]] = 1;
        return x & y;
    } else {
        if (x == 1) c[son[u][1]] = 1;
        if (y == 1) c[son[u][0]] = 1;
        return x | y;
    }
}
void dfs2(int u) {
    if (u <= n) return;
    c[son[u][0]] |= c[u];
    c[son[u][1]] |= c[u];
    dfs2(son[u][0]);
    dfs2(son[u][1]);
}
int main() {
    gets(s);
    scanf("%d", &n);
    ck = n;
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    stack<int> b;
    for (int i = 0; s[i]; i += 2) {
        if (s[i] == 'x') {
            int x = 0;
            i++;
            while (s[i] != ' ') {
                x = x * 10 + s[i] - '0';
                i++;
            }
            i--;
            b.push(x);
        } else if (s[i] == '&') {
            int x = b.top();
            b.pop();
            int y = b.top();
            b.pop();
            b.push(++ck);
            a[ck] = 2;
            son[ck][0] = x;
            son[ck][1] = y;
        } else if (s[i] == '|') {
            int x = b.top();
            b.pop();
            int y = b.top();
            b.pop();
            b.push(++ck);
            a[ck] = 3;
            son[ck][0] = x;
            son[ck][1] = y;
        } else if(s[i] == '!'){
            flag[b.top()] ^= 1;
        }
    }
    int ans = dfs(ck, flag[ck]);
    dfs2(ck);
    scanf("%d", &q);
    while (q--) {
        int x;
        scanf("%d", &x);
        printf("%d\n", c[x] ? ans : !ans);
    }
    return 0;
}

[CSP-J2020] 方格取數

這道題沒有上面那個難，但是也是一道非常難想的題。

三維動態規劃思路：
由於有三個方向，所以在普通二維dp上再加一個方向維度，用三維陣列進行dp。

f[i][j][→] -> f[i][j][0] 表示從當前格子的左邊走到當前格子能取到的最大整數之和。
f[i][j][↓] -> f[i][j][1] 表示當前格子的上邊走到當前格子能取到的最大整數之和。
f[i][j][↑] -> f[i][j][2] 表示當前格子的下邊走到當前格子能取到的最大整數之和。

先進行第 1 列的填值。
因為其處在整個地圖的最左側，所以只有 ↓ 方向是可以取到格子裡的數的（如果向上走，最後必將無路可走）。
f[i][1][1] = f[i-1][1][1] + a[i][1]
然後再進行第 2 ~ m 列的填值。
先填 → 方向及 ↓ 方向的值，再從下往上填 ↑ 方向的值。

f[i][j][0] = max(f[i][j-1][0],f[i][j-1][1],f[i][j-1][2]) + a[i][j]
f[i][j][1] = max(f[i-1][j][0],f[i-1][j][1]) + a[i][j]
f[i][j][2] = max(f[i+1][j][0],f[i+1][j][2]) + a[i][j]

最後輸出：
max(f[n][m][0],f[n][m][1],f[n][m][2])

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define inf -1e17
ll f[1005][1005][3];
ll a[1005][1005];
int n,m;
ll maxx(ll a,ll b)
{
    return a>b ?a :b;
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cin>>a[i][j];
            f[i][j][0] = inf;
            f[i][j][1] = inf;
            f[i][j][2] = inf;

        }
    }
    f[1][1][0]=a[1][1];
    f[1][1][1]=a[1][1];
    f[1][1][2]=a[1][1];
    for(int i=2;i<=n;i++)
    {
        f[i][1][1] = f[i-1][1][1] + a[i][1];
    }
    for(int j=2;j<=m;j++)
    {
        for(int i=1;i<=n;i++)
        {
            f[i][j][0]=maxx(f[i][j-1][1],maxx(f[i][j-1][0],f[i][j-1][2]))+a[i][j];
            if(i>=2) f[i][j][1]=maxx(f[i-1][j][0],f[i-1][j][1])+a[i][j];  //↓方向
        }
        for(int i=n-1;i>=1;i--)  //↑方向
        {
            f[i][j][2]=maxx(f[i+1][j][0],f[i+1][j][2])+a[i][j];
        }
    }
    cout<<maxx(f[n][m][0],maxx(f[n][m][1],f[n][m][2]));
    return 0;
}