2016-2017 ACM-ICPC Pacific Northwest Regional Contest (Div. 2) 【部分题解】

A：因为删除是不计入操作次数的，所以转化一下就是求最长上升子序列，简单dp。

     设dp[i]表示前i个字符能凑成上升子序列的最大长度，dp[i] = max(dp[j]+1, dp[i]) 【j < i && s[j] < s[i]】

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = 1e6+5;

string s;
int dp[105];

int main()
{
    //FIN;
    cin >> s;
    int len = s.size(), maxn = 0;
    rep(i, 1, len){
        dp[i] = 1;
        rep(j, 1, i-1){
            if(s[j-1] < s[i-1]) dp[i] = max(dp[j]+1, dp[i]);
        }
        maxn = max(maxn, dp[i]);
    }
    cout << 26-maxn << endl;
    return 0;
}

B：可以看出题目其实就是让你求有多少对哑铃片，每一片哑铃只能用一次且这一对重量相同。

     最多只可能有14个哑铃片，因此我们可以用二进制进行枚举，假设二进制是 101011(高->低)，那么表示1,2,4,6号哑铃片被选中了；

     这样的话最多 2^14种重量，接下来我们只需要判断一下相同重量的方案是不是满足每种哑铃片只用了一次。

     eg: 假设 1001和1100构成的重量是相同的，但是它们都选择了4号哑铃片，所以这种情况是不满足题意的，只有 1001和 0110这种情况满足；

     可见判断标准就是看两个方案的二进制数的按位与操作的结果是不是0，是的话表示满足，不是的话表示有重复使用，则不满足。

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = (1<<16);

int n, m;
LL a[20], b[20];
vector <LL> ans, ANS;
map <LL, bool> vis, VIS;
struct Node{
    int bt;
    LL val;
    bool operator < (const Node &r) const   { return val < r.val; }
}node[N];

bool judge(int i, int j){
    int a = node[i].bt, b = node[j].bt;
    if(a&b) return false;
    return true;
}
int main()
{IO;
    //FIN;
    cin >> n >> m;
    rep(i, 1, n)    cin >> a[i];
    rep(i, 1, m)    cin >> b[i];

    rep(i, 0, ((1<<m)-1)){
        int bit = i, p = 1;
        LL res = 0;
        while(bit){
            if(bit&1)   res += b[p];
            p++; bit >>= 1;
        }
        node[i].val = res;
        node[i].bt = i;
    }
    sort(node, node+(1<<m));
    int i = 0;
    while(i < (1<<m)){
        int j = i+1;
        if(vis[node[i].val])    { i++; continue; }
        while(j < (1<<m)){
            if(node[i].val != node[j].val)  break;
            if(judge(i, j)){
                if(!vis[node[i].val]) ans.pb(node[i].val);
                vis[node[i].val] = true;
            }
            j++;
        }
        i++;
    }
    //rep(i, 0, (int)ans.size()-1)    cout << ans[i] << " ";
    rep(i, 1, n){
        if(!VIS[a[i]])  ANS.pb(a[i]);
        VIS[a[i]] = true;
        rep(j, 0, (int)ans.size()-1){
            LL res = a[i]+ans[j]*2;
            if(!VIS[res]) ANS.pb(res);
            VIS[res] = true;
        }
    }
    sort(ANS.begin(), ANS.end());
    rep(i, 0, (int)ANS.size()-1)    cout << ANS[i] << endl;
    return 0;
}

C：貌似还没补。。。。。。

D：这是一道贪心题，我们可以从左往右贪心。假设当前位置是pos，那么我们可以看一下pos往右的长度为r的区间内有几个摄像机，

     如果大于2，那么不需要放，否则需要放1个或2个。我们为了使摄像机充分利用，那么我们尽可能把摄像机给右边放，也就是说，

     我们从 pos+r-1 的位置往左扫，碰到没有摄像机的位置给它放就行了，知道 [pos, pos+r-1]这个区间的摄像机不少于2个就好。

     快速判断 [pos, pos+r-1]的摄像机个数，有的位置标记1，没有的标记0，那么区间求和就是摄像机个数；

     快速求区间和操作可以看看树状数组，当然可以用前缀和以及特殊的处理也可以搞定这个题。

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = 1e5+5;

LL n, k, r, x, c[N];
bool vis[N];

int lowbit(int x)   { return x&-x; }
void add(int id, int p){
    while(id <= n){
        c[id] += p;
        id += lowbit(id);
    }
}
LL sum(int id){
    LL ans = 0;
    while(id >= 1){
        ans += c[id];
        id -= lowbit(id);
    }
    return ans;
}
int main()
{IO;
    //FIN;
    cin >> n >> k >> r;
    rep(i, 1, k)    { cin >> x; vis[x] = true; add(x, 1); }
    LL ans = 0;
    rep(i, 1, n-r+1){
        LL res = sum(i+r-1)-sum(i-1);
        if(res < 2){
            per(j, i+r-1, i){
                if(res >= 2) break;
                if(!vis[j]){
                    add(j, 1);
                    vis[j] = true;
                    ans++;
                    res++;
                }
            }
        }
    }
    cout << ans << endl;
    return 0;
}

E：按照题意，我们每次是从长度为k的序列中找罚时最小的来处理的，那么只需要用个优先队列，每次把最小的pop出来，然后按照题意进行模拟就行了。

     关于优先队列的用法请出门右拐百度 "STL 优先队列"

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = 1e6+5;

int n, k, a[305];
priority_queue<int, vector<int>, greater<int> > Q;

int main()
{
    //FIN;
    cin >> n >> k;
    rep(i, 1, n)    cin >> a[i];
    LL ans = 0, pre = 0, tol = 0;
    rep(i, 1, k)    Q.push(a[i]);

    int id = k+1;
    while(!Q.empty()){
        ans = pre+Q.top(); Q.pop();
        pre = ans;
        tol += ans;
        if(id <= n) { Q.push(a[id]); id++; }
    }
    cout << tol << endl;
    return 0;
}

F：签到题，判断a + b = c，处理读入可以简化操作。

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = 1e6+5;

int a, b, c;

int main()
{
    scanf("%d + %d = %d", &a, &b, &c);
    if(a+b == c)    printf("YES
");
    else printf("NO
");
    return 0;
}

G：苹果下落，按照题意模拟就行了。把每个苹果往下掉，直到不能掉为止。注意有坑点，有可能上下是多个苹果相连，

     那么如果判断条件不合理的话，最后结果只是最底下的一层掉落了。因此我们可以从下往上模拟就不会出现这个问题了。

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = 1e6+5;

int n, m, G[55][55];
string s;

int main()
{
    //FIN;
    cin >> n >> m;
    rep(i, 1, n){
        cin >> s;
        rep(j, 0, m-1){
            if(s[j] == 'o') G[i][j+1] = 0;
            if(s[j] == '#') G[i][j+1] = -1;
            if(s[j] == '.') G[i][j+1] = 1;
        }
    }
    per(i, n, 1){
        rep(j, 1, m){
            if(G[i][j] == 0){
                int id = i+1;
                while(id <= n && G[id][j] == 1) id++;
                swap(G[i][j], G[id-1][j]);
            }
        }
    }
    rep(i, 1, n){
        rep(j, 1, m){
            if(G[i][j] == 0)    cout << 'o';
            if(G[i][j] == 1)    cout << '.';
            if(G[i][j] == -1)   cout << '#';
        }
        cout << endl;
    }
    return 0;
}

H：题意是让你求L的联通块个数，C可以代表L或者W。这是个简单的搜索题，试想一下，如果我当前有个位置是L，那么我肯定这个联通块是存在的，

     那么往下搜索碰到C时，我如果把C当成L处理，对于我最后联通块的数目是只可能减少，不可能增加的。因为刚开始已经是一个L往下搜索，肯定是有一个联通块了，

     碰到C的，我可以吧 LCL这种连在一起，因此只减不增。

     使用到的技巧：可以每次dfs完了之后把经过的点变成W，这样以后就不用再走了。注意第一样例这种特殊判断的情况。

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = 1e6+5;

int n, m, res, G[55][55], dir[4][2] = {0,1,0,-1,1,0,-1,0};
string s;

bool judge(int x, int y){
    if(x < 1 || x > n || y < 1 || y > m || G[x][y] == -1)    return false;
    return true;
}
void dfs(int x, int y){
    rep(i, 0, 3){
        int xi = x+dir[i][0], yi = y+dir[i][1];
        if(judge(xi, yi)){
            G[xi][yi] = -1;
            dfs(xi, yi);
        }
    }
    return ;
}
int main()
{
    //FIN;
    cin >> n >> m;
    rep(i, 1, n){
        cin >> s;
        rep(j, 0, m-1){
            if(s[j] == 'C') G[i][j+1] = 0;
            if(s[j] == 'W') G[i][j+1] = -1;
            if(s[j] == 'L') G[i][j+1] = 1;
        }
    }
    int ans = 0;
    rep(i, 1, n){
        rep(j, 1, m){
            if(G[i][j] == 1){
                ans++;
                dfs(i, j);
            }
        }
    }
    cout << ans << endl;
    return 0;
}

I： 我们贪心的想一下，就可以发现，我能配对多少对袜子是和我的maxn和tol有关的。

     如果 tol/2 >= maxn,结果就是 tol/2, 否则的话结果就是 tol-maxn；具体可以多试几组数据画一画理解一下。

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = (1<<16);

int n;
LL x;

int main()
{IO;
    //FIN;
    cin >> n;
    LL tol = 0, maxn = 0;
    rep(i, 1, n)    { cin >> x; maxn = max(maxn, x); tol += x; }
    cout << (tol >= maxn*2 ? tol/2 : tol-maxn) << endl;
    return 0;
}

J：这也是一道贪心题，我们需要把位置大于0和小于0分开处理。对于每种情况，因为我们一趟所带的信封是固定的，

    所以我们肯定是想要把最远的位置跑的趟数尽可能少，那么只需要从远及近派送信封即可，每次送完信封还有剩余的时候，我们可以把它送给下一个位置。

    这样正负两种情况都处理一下就可以解决了。

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = (1<<16);

int n;
LL k;

struct Node{
    int pos;
    LL c;
    bool operator < (const Node &r) const   { return pos < r.pos; }
}node[1005];

int main()
{IO;
    //FIN;
    cin >> n >> k;
    rep(i, 1, n)    cin >> node[i].pos >> node[i].c;
    sort(node+1, node+n+1);
    LL ans = 0, res = 0;
    int i = n;
    while(i >= 1){
        if(node[i].pos < 0) break;
        LL cnt = (node[i].c+k-1)/k;
        ans += node[i].pos*cnt;
        LL sum = cnt*k;
        while(i >= 1 && sum && node[i].pos >= 0){
            if(node[i].c <= sum)    { sum -= node[i].c; i--; }
            else { node[i].c -= sum; break; }
        }
    }
    i = 1;
    while(i <= n){
        if(node[i].pos >= 0) break;
        LL cnt = (node[i].c+k-1)/k;
        ans -= node[i].pos*cnt;
        LL sum = k*cnt;
        while(i <= n && sum && node[i].pos < 0){
            if(node[i].c <= sum)    { sum -= node[i].c; i++; }
            else { node[i].c -= sum; break; }
        }
    }
    cout << ans*2 << endl;
    return 0;
}

K：掷骰子判断a赢的概率，总共只有6*6=36种情况，最后的结果 ans = a赢 / (36 - 平局)；高中简单概率计算题

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = 1e6+5;

int a[10], b[10];

int main()
{
    //FIN;
    rep(i, 1, 6)    cin >> a[i];
    rep(i, 1, 6)    cin >> b[i];
    double cnt1 = 0, cnt2 = 0;
    rep(i, 1, 6){
        rep(j, 1, 6){
            if(a[i] > b[j]) cnt1++;
            if(a[i] == b[j])    cnt2++;
        }
    }
    printf("%.5lf
", cnt1*1.0/(36-cnt2));
    return 0;
}

L：可以知道，只有三种矩形，那么无论怎么拼，其中的最长边才有可能是最后正方形的边长的，基于这一点，可以分类讨论一下。

#include<bits/stdc++.h>
#define  IO ios_base::sync_with_stadio(0);cin.tie(0);
using namespace std;
int a[55][55];
int main()
{
    int a1, b1, a2, b2, a3, b3;
    while(cin >> a1 >> b1 >> a2 >> b2 >> a3 >> b3){
        int a = max(a1, b1);
        int b = max(a2, b2);
        int c = max(a3, b3);
        int d = a, flag = 1;
        if(b > d){d = b; flag = 2;}
        if(c > d){d = c; flag = 3;}
        if(flag == 1){
            int e = a2 + a3;
            int f = a2 + b3;
            int g = b2 + a3;
            int h = b2 + b3;
            if(e == d){
                if(b2 == b3 && (b2 + a1 == d || b2 + b1 == d)){ cout << "YES" << endl; continue;}
            }
            if(f == d){
                if(b2 == a3 && (b2 + a1 == d || b2 + b1 == d)) { cout << "YES" << endl; continue;}
            }
             if(g == d){
                if(a2 == b3 && (a2 + a1 == d || a2 + b1 == d)) { cout << "YES" << endl; continue;}
            }
             if(h == d){
                if(a2 == a3 && (a2 + a1 == d || a2 + b1 == d)) { cout << "YES" << endl; continue;}
            }
        }
        else if(flag == 2){
            int e = a1 + a3;
            int f = a1 + b3;
            int g = b1 + a3;
            int h = b1 + b3;
            if(e == d){
                if(b1 == b3 && (b1 + a2 == d || b1 + b2 == d)){ cout << "YES" << endl; continue;}
            }
            if(f == d){
                if(b1 == a3 && (b1 + a2 == d || b1 + b2 == d)) { cout << "YES" << endl; continue;}
            }
             if(g == d){
                if(a1 == b3 && (a1 + a2 == d || a1 + b2 == d)) { cout << "YES" << endl; continue;}
            }
             if(h == d){
                if(a1 == a3 && (a1 + a2 == d || a1 + b2 == d)) { cout << "YES" << endl; continue;}
            }
        }
        else if(flag == 3){
            int e = a2 + a1;
            int f = a2 + b1;
            int g = b2 + a1;
            int h = b2 + b1;
            if(e == d){
                if(b2 == b1 && (b1 + a3 == d || b1 + b3 == d)){ cout << "YES" << endl; continue;}
            }
            if(f == d){
                if(b2 == a1 && (b2 + a3 == d || b2 + b3 == d)) { cout << "YES" << endl; continue;}
            }
             if(g == d){
                if(a2 == b1 && (b1 + a3 == d || b1 + b3 == d)) { cout << "YES" << endl; continue;}
            }
             if(h == d){
                if(a2 == a1 && (a1 + a3 == d || a1 + b3 == d)) { cout << "YES" << endl; continue;}
            }
        }
        cout << "NO" << endl;
    }
}

M：题意是让你找最长交错子序列，这个序列是上升下降或者下降上升交错出现的。其实这个题的本质和A的最长上升子序列是一样的，

     最长上升是在每个位置i我们找的是i之前的最长上升，这道题换成了两种情况

     一种情况是假设当前要上升的话，我们找i之前的最长下降。另一种是假设当前下降，我们找i之前的最长上升，用两个dp数组就可以解决了。

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define pb push_back
typedef long long LL;
typedef pair<int, LL> PIR;
const int N = 1e6+5;

int n, a[55], dp[55][2];

int main()
{
    //FIN;
    cin >> n;
    rep(i, 1, n)    cin >> a[i];
    int maxn = 1;
    rep(i, 1, n){
        dp[i][0] = dp[i][1] = 1;
        rep(j, 1, i-1){
            if(a[j] > a[i]) dp[i][0] = max(dp[i][0], dp[j][1]+1);
            if(a[j] < a[i]) dp[i][1] = max(dp[i][1], dp[j][0]+1);
        }
        maxn = max(maxn, max(dp[i][0], dp[i][1]));
    }
    cout << maxn << endl;
    return 0;
}