Diary_2.25

AtCoder

1. Paint to make a rectangle

void solve(){
    int h, w;   cin >> h >> w;
    string a[h];
    for(int i=0; i<h; i++)  cin >> a[i];
    int mxx = 0, mxy = 0, mnx = 1e9, mny = 1e9;
    for(int i=0; i<h; i++){
        for(int k=0; k<w; k++){
            if(a[i][k] == '#'){
                mxx = max(mxx, k);
                mxy = max(mxy, i);
                mnx = min(mnx, k);
                mny = min(mny, i);
            }
        }
    }
    for(int i=mny; i<=mxy; i++){
        for(int k=mnx; k<=mxx; k++){
            if(a[i][k] == '.'){
                cout << "No" << endl;
                return;
            }
        }
    }
    cout << "Yes" << endl;
}

2. Stone XOR

#define int long long
const int maxn = 12;
int n, a[maxn];
vector<int> q;
set<int> ans;
void dfs(int now){
    int len = q.size(), cnt = 0;
    if(now == n){
        for(int i=0; i<len; i++){
            cnt ^= q[i];
        }
        ans.insert(cnt);
        return;
    }
    for(int i=0; i<len; i++){
        q[i] += a[now];
        dfs(now+1);
        q[i] -= a[now];
    }
    q.push_back(a[now]);
    dfs(now+1);
    q.pop_back();
}
void solve(){
    cin >> n;
    for(int i=0; i<n; i++)  cin >> a[i];
    dfs(0);
    cout << ans.size() << endl;
}

3. Snake Queue

#define int long long
const int maxn = 3e5+10;
struct node{
	int head, tail, len;
};
node a[maxn];
void solve(){
	int q;	cin >> q;
	int op, head = 1, tail = 0, len;
	int dif = 0;
	for(int i=0; i<q; i++){
		cin >> op;
		if(op == 1){
			cin >> len;
			int new_head = a[tail].tail+1;
			int new_tail = new_head+len-1;
			tail++;
			a[tail] = {new_head, new_tail, len};
		}else if(op == 2){
			dif += a[head++].len;
		}else{
			int k;	cin >> k;
			cout << a[head+k-1].head-dif-1 << endl;
		}
	}
}

4. Vitamin Balance

#define int long long
const int maxn = 5e3+10;
int n, x, dp[3][maxn], pos_ori[3];
struct node{
    int a, c;
};
node ori[3][maxn];
void get_dp(int now){
    for(int i=0; i<pos_ori[now]; i++){
        for(int k=x; k>=ori[now][i].c; k--){
            dp[now][k] = max(dp[now][k], dp[now][k-ori[now][i].c]+ori[now][i].a);
        }
    }
    for(int i=1; i<=x; i++){
        dp[now][i] = max(dp[now][i], dp[now][i-1]);
    }
}
void solve(){
    cin >> n >> x;
    int v, a, c;
    for(int i=0; i<n; i++){
        cin >> v >> a >> c;
        v--;
        ori[v][pos_ori[v]++] = {a, c};
    }
    for(int i=0; i<3; i++){
        get_dp(i);
    }
    int l = 0, r = 1e10+10, ans = 0;
    while(l < r){
        bool is_l = false;
        int mid = (l+r)/2, cnt = 0;
        for(int i=0; i<3; i++){
            int pos = lower_bound(dp[i], dp[i]+x+1, mid)-dp[i];
            if(pos == x+1 || pos < 0){
                is_l = true;
                break;
            }
            cnt += pos;
        }
        if(is_l || cnt > x){
            r = mid;
        }else{
            ans = mid;
            l = mid+1;
        }
    }
    cout << ans << endl;
}

5. Pigeonhole Query

const int maxn = 1e6+10;
int cnt, len[maxn], pos[maxn];
void solve(){
    int n, q;   cin >> n >> q;
    for(int i=1; i<=n; i++){
        len[i] = 1;
        pos[i] = i;
    }
    int u, v, op;
    for(int i=0; i<q; i++){
        cin >> op;
        if(op == 1){
            cin >> u >> v;
            int ru = pos[u];
            pos[u] = v;
            len[ru]--, len[v]++;
            if(len[ru] == 1)    cnt--;
            if(len[v] == 2)     cnt++;
        }else{
            cout << cnt << endl;
        }
    }
    // 数据结构暴力模拟，时间复杂度显著大于前面的算法
    // unordered_map<int, int> pos;
    // for(int i=1; i<=n; i++) pos[i] = i;
    // vector<unordered_map<int, bool>> tree(n+1);
    // for(int i=1; i<=n; i++){
    //     tree[i][i] = true;;
    // }
    // int ans = 0, u, v;
    // for(int i=0; i<q; i++){
    //     int op; cin >> op;
    //     if(op == 1){
    //         cin >> u >> v;
    //         int pu = pos[u];
    //         pos[u] = v;
    //         len[pu]--, len[v]++;
    //         tree[pu][u] = false;
    //         tree[v][u] = true;
    //         if(len[pu] == 0)    ans--;
    //         if(len[v] == 1)    ans++;
    //     }else{
    //         cout << ans << endl;
    //     }
    // }
}

6. Outstanding Impressionist

struct node{
    int l, r;
};
void solve(){
    int n;  cin >> n;
    node a[n];
    int q[2*n+2], dif[2*n+2];
    memset(q, 0, sizeof(q));
    memset(dif, 0, sizeof(dif));
    for(int i=0; i<n; i++){
        cin >> a[i].l >> a[i].r;
        if(a[i].l == a[i].r)    q[a[i].l]++, dif[a[i].l] = 1;
    }
    for(int i=1; i<=2*n; i++)   dif[i] += dif[i-1];
    for(int i=0; i<n; i++){
        if(a[i].l == a[i].r){
            if(q[a[i].l] == 1){
                cout << 1;
            }else{
                cout << 0;
            }
            continue;
        }
        if(dif[a[i].r]-dif[a[i].l-1] == a[i].r-a[i].l+1)    cout << 0;
        else    cout << 1;
    }
    cout << endl;
}