编程俱乐部月赛21.3.4

先简单说一下，本次月赛比赛感受：
表现好的： 1. 对之前算时一个突破的点是:对于比赛坚持的时间比较长了，从前因为做不出题就直接下号了，这次我在最后半小时内优化了一个时间超限的代码，多做出来一道； 2. 合理舍掉没把握的题，头铁现象明显不那么严重了。
表现不好的，见下面每道题的分析吧。

A.zhb去做客

这题，很多人做出来了，我当时很懵，我纳闷，为啥我读不懂题，对，是我有问题。
虽然很简短， 但还是要说一下题目大意的。

n个数字，每次随意删掉两个数a, b,并在最后写上这两个数的和 % 11的结果，最后剩两个数。给出最后两个数中的一个t，求另一个。

代码中的细节，细品
细节

1. 假如输入了两个数，给出其中一个了，另一个本身就是答案，不能再对11取模的了
2. 因为涉及到的数值较大，我们得设long long
3. 代码中必然涉及到一个flag作用。

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 150000 + 10;
int num[N];
long long sum;

int main(void){
    int n, t;
    scanf("%d%d", &n, &t);
    for(int i = 0; i < n; i ++){
        scanf("%d", &num[i]);
    }
    bool flag = true;
    for(int i = 0; i < n; i ++){
        if(num[i] == t && flag){
            flag = false;
        }
        else{
            sum += (num[i] % 11);
            sum %= 11;
            if(n == 2)  sum = num[i];
        }
    }
    printf("%d\n", sum);
    return 0;
}

B. zhb的寒假作业（二分+贪心）

乍一看，我以为是bfs呢，我也觉得我这操作不靠谱。直接隔过去了。。

分析

1. 主要考察 二分+贪心的应用。因为主要分成了 k 段，
2. 二分的目的：要想时间最短最少，每个人写的页数尽量平均，我们找出这样一个页数。
   两段性：找着的目标值T应该满足， T的左边分的段数大于k，右边满足小于等于k段。
3. check函数： mid满足划分的不超过k个时，我们要尽量让l尽可能小，这个l就是我们找着的最优解（即花费的最短时间）。
   mid在满足check后，我们要找满足条件的最小值，所以让r = mid
4. 贪心的思想：因为要尽可能保证前边的人写的作业少，我们让后边的人先选，在满足不超过最大值T的情况下，尽可能的多选，这样就能保证前边的人花费时间最少。【一个小细节，我们的书是有顺序的】

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 510;
int n, k;
int a[N], L[N], R[N];//L存储当前这段区间的左区间，R存储当前这段区间的右区间
int cnt;

bool check(int mid){
    int cnt = 1;
    long long sum = 0;
    for(int i = 1; i <= n; i ++){
        if(sum + a[i] <= mid) sum += a[i];
        else{
            cnt ++;
            sum = a[i];
        }
    }
    return cnt <= k;
}

int main(void){
    scanf("%d%d", &n, &k);
    int l = 0, r = 1e9;
    for(int i = 1; i <= n; i ++){
        scanf("%d", &a[i]);
        l = max(l, a[i]);
    }
    while(l < r){
        int mid = l + r >> 1;
        if(check(mid)) r = mid;
        else l = mid + 1;//二分时的l最小值为每本作业页数的最大值
    }
    long long sum = 0;
    R[cnt] = n;//最后一个区间的右端点
    for(int i = n; i > 0; i --){
        if(sum + a[i] <= l) sum += a[i];
        else{
            L[cnt] = i + 1;
            cnt ++;
            R[cnt] = i;
            sum = a[i];
        }
    }
    L[cnt] = 1;//第一个区间的左端点
    for(int i = cnt; i >= 0; i --){
        cout << L[i] << " " << R[i] << endl;
    }
    return 0;
}

C.转账的最小花费

勤能补拙，这句话还是很有道理的，当做了十几道最短路后，心就不虚了，敲的胆子也大了。

当时写出题的思路：扣除z%的手续费，我们的dis[i]数组，不妨直接定义为，x点100元能换成多少i元。接下来用的Dijkstra套进去即可。

下面示例代码，主要展示spfa算法的实现。
利用的思想：d(A) * w1 * w2 * ... = 100, 那么我们想让A初始钱最少就应该求出A到B的乘积最长路
关于spfa算法的原理，以及另一道模板题，可参见本人这篇博客
博客链接

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;
const int N = 2010, M = 2 * 1e5 + 10;
int h[N], e[M], ne[M], idx;
int n, m, S, E;
double dis[N], w[M];
bool st[N];

void add(int a, int b, double c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

double spfa(){
    memset(dis, 0x3f, sizeof(dis));
    dis[S] = 1;
    queue <int> q;
    q.push(S);
  //  st[S] = true;
    while(q.size()){
        int t = q.front();
        q.pop();
        st[t] = false;
        for(int i = h[t]; i != -1; i = ne[i]){
            int j = e[i];
            if(dis[j] < dis[t] * w[i]){
                dis[j] = dis[t] * w[i];
                if(!st[j]){
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return 100 / dis[E];
}

int main(void){
    cin >> n >> m;
    memset(h, -1, sizeof(h));
    for(int i = 1; i <= m; i ++){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        double z = (100.0 - c) / 100;
        add(a, b, z), add(b, a, z);
    }
    cin >> S >> E;
    printf("%.2f\n", spfa());
    return 0;
}

D.GHH爱寻宝

题目大意：
输入一个 n行m列的矩阵，输出每一个位置下标(i, j), 的i行j列的和。1 <= n * m <= 1000000
每个宝物的价值范围 -1e9 <= w <= 1e9

我们数组开不了k[1e6][1e6]这么大的，就要想办法用一维解决该问题。

法一：
我们输入编号从0开始，一直到n*m-1为止，假如该位置的编号为k，对应的行坐标 i = k / m; 纵坐标 j = k % m;[此时的i，j相当于二维数组中均是从0， 0开始的]
细节：输出时，lld%,因为涉及的数据范围比较大，我们要用scanf 、 printf

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e6 + 10;
int mp[N];
long long hang[N], lie[N]; //存储每行每列的和。
int n, m;
int main(void){
    scanf("%d%d", &n, &m);
    int k = n * m;
    int h = 0, l = -1;
    for(int i = 0; i < k; i ++){
        scanf("%d", &mp[i]);
        hang[h] += mp[i];
        lie[++ l] += mp[i];
        if( (i + 1) % m == 0) h ++, l = -1;
    }
    h = 0, l = -1;
    for(int i = 0; i < k; i ++){
        printf("%lld", hang[h] + lie[++ l] - mp[i]);
        if((i + 1) % m == 0) printf("\n");
        else printf(" ");
        if( ( i + 1) % m == 0){
            h ++;
            l = -1;
        }
    }
    return 0;



}

法二：
我们依旧采用二维数组输入的方式，即两重循环对应i行，j列， i * m + j 即对应的一维中对应的数字。

#include <algorithm>
#include <iostream>
using namespace std;
const int N = 1e6+10;
long long a[N], h[N], l[N];
int n, m;
int main(void){
    scanf("%d%d", &n, &m);
    int p;
    for(int i = 0; i < n; i ++){
        for(int j = 0; j < m; j ++){
            scanf("%d", &p);
            a[i * m + j] = p;
            h[i] += p;
            l[j] += p;
        }
    }
    for(int i = 0; i < n; i ++){
        for(int j = 0; j < m; j ++){
            printf("%lld ", h[i] + l[j] - a[i * m + j]);
        }
        printf("\n");
    }
    return 0;
}

E.zhb来串门

题目大意：求连通块的数量。本人用的dfs，可参见本人这篇博客中的一道相似例题dfs求连通块问题
博客链接

下面展示bfs写法。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
const int N = 110;
typedef pair<int, int> PII;
int n, m, g[N][N];
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};

void bfs(int x, int y){
    queue<PII> que;
    que.push({x, y});
    g[x][y] = 0;
    while(que.size()){
        PII t = que.front();
        que.pop();
        for(int i = 0; i < 4; i ++){
            int nx = t.first + dx[i], ny = t.second + dy[i];
            if(nx < 0 || nx >= n || ny < 0 || ny >= m || !g[nx][ny]){
                continue;
            }
            que.push({nx, ny});
            g[nx][ny] = 0;
        }
    }

}

int main(void){
    int t;
    scanf("%d", &t);
    while(t --){
        scanf("%d%d", &n, &m);
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < m; j ++){
                scanf("%d", &g[i][j]);
            }
        }
        int cnt = 0;
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < m; j ++){
                if(g[i][j]){
                    bfs(i, j);
                    cnt ++;
                }
            }
        }
        cout << cnt << endl;
    }
    return 0;
}

F. GHH割韭菜

做题思路：我们要想时间最少，每次割最大高度的一半，即可。其实当时我也不确定，只能尝试写几个数，1-7吧，琢磨怎么才能时间最短，便找出了规律/、。。

#include <algorithm>
#include <iostream>
using namespace std;

int main(void){
    int n;
    cin >> n;
    int sum = 0;
    while(n){
        n /= 2;
        sum ++;
    }
    cout << sum << endl;
    return 0;
}

G.zhb 和 hcr玩游戏

n堆彩虹糖，zhb和hcr轮流操作，每次操作都可以取一堆彩虹糖，放进两堆数目比这堆少的彩虹糖堆里（被放入的堆可以彩虹糖数目为0， 既可以创建新堆，放入之后的新堆彩虹糖数目也要小于选取堆的彩虹糖数目）最后无法操作的人会输掉比赛。zhb先操作。
输入：
第一行整数n，表示彩虹糖的堆数
第二行n个整数，其中第i个整数表示第i堆彩虹糖的数量ai（1 <= n, ai <= 100）
输出：
输出共一行，zhb胜输出 zhb， 否则，输出hcr

分析：
此题为拆分nim的板子，具体可参见小编的这篇总结
博客链接

代码如下：

#include <algorithm>
#include <iostream>
#include <unordered_set>
#include <cstring>
using namespace std;
const int N = 110;
int f[N];

int SG(int x){
    if(f[x] != -1) return f[x];
    unordered_set<int>S;
    for(int i = 0; i < x; i ++){
        for(int j = 0; j <= i; j ++){
            S.insert(SG(i) ^ SG(j));
        }
    }
    for(int i = 0; ; i ++){
        if(!S.count(i)) return f[x] = i;
    }

}

int main(void){
    int n;
    cin >> n;
    int res = 0;
    memset(f, -1, sizeof(f));
    for(int i = 0; i < n; i ++){
        int x;
        cin >> x;
        res ^= SG(x);
    }
    if(res) cout << "zhb" << endl;
    else cout << "hcr" << endl;
    return 0;
}