被打日常 20191012

E题一个下午自闭，被吊打是日常的事情，不用奇怪。

刚开始是当成类似灯的开关问题，从左到右把1e9的长度分成最多2*n段然后还特判了一小时，再二分，结果......当然.......TLE

之后看正解，是对特定的点进行差分,把渔夫当成是点，对于每一条鱼的区间加1，然后一次性得到答案

http://codeforces.com/gym/101964/problem/E

#include <stdio.h>
#include <algorithm>
#include <map>
using namespace std;
const int maxn = 1e9;
struct node {
    int id, flag;
}point[200015];
int n, m, l;
int x[200015], y[200015], sum[200015], ans[200015];
bool cmp(node a, node b) {
    return a.flag < b.flag;
}
struct enode {
    int p;
    int id;
    bool operator < (const enode &a) const{
        return p < a.p;
    }
}se[200015];
int tot1 = 1;
int cnt = 0;
int main()
{
    scanf("%d%d%d", &n, &m, &l);
    for(int i = 1; i <= n; i++) {
        scanf("%d%d", &x[i], &y[i]);
    }
    for (int i = 1; i <= m; i++) {
        scanf("%d", &se[i].p);
        se[i].id = i;
    }
    sort(se+1, se+1+m);
    enode tmp;
    for (int i = 1; i <= n; i++) {
        if (y[i] > l) continue;
        tmp.p = x[i] - (l-y[i]);
        int p = lower_bound(se+1, se+1+m, tmp) - se;
        sum[p]++;
        tmp.p = x[i] + (l-y[i]);
        p = upper_bound(se+1, se+1+m, tmp) - se;
        sum[p]--;
    }
    for (int i = 1; i <= m; i++) {
        sum[i] = sum[i] + sum[i-1];
        ans[se[i].id] = sum[i];
    }
    for (int i = 1; i <= m; i++)
        printf("%d
", ans[i]);
    return 0;
}

C题 最小生成树 有黑白之分， 需求是从n个点中挑出m个点，使得最小生成树最大的黑点连边的最小费用

看别人说最大的最小通常二分，现在枚举lim作为最大连边

最小生成树也是树，bfs序的点被访问到的时候肯定是在被访问到过的点连成的最小生成树的叶结点，从这个点开始dfs以lim作为限制搜索的深度

如果最后搜索到的点数比m多，此时的 lim 大于等于 挑出m个点的最大费用的最小费用

m >= 1 这就意味着有不加边的可能 l = 0，还是wa了

http://codeforces.com/gym/101964/problem/C

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <queue>
#include <algorithm>

using namespace std;

const int maxn = 105;
int col[maxn];
int n, m;
bool vis[maxn];
struct node{
    int v,nxt;
}edge[maxn*2];
int tot, head[maxn];
void Insert(int u, int v) {
    edge[++tot].v = v;
    edge[tot].nxt = head[u];
    head[u] = tot;
}
int dfs(int u, int fa, int lim, int dis) {
    int res = col[u];
    if (dis >= lim) return res;
    for (int i = head[u]; i; i = edge[i].nxt) {
        int v = edge[i].v;
        if (fa == v || vis[v] == false) continue;
        res = res + dfs(v, u, lim, dis+1);
    }
    
    return res;
}
bool check(int lim) {
    memset(vis, 0, sizeof(vis));
    queue <int> q;
    q.push(1);
    while (!q.empty()) {
        int t = q.front();q.pop();
        vis[t] = 1;
        int tt = dfs(t, -1, lim, 0);
        if (tt >= m) return true;
        for (int i = head[t]; i; i = edge[i].nxt) {
            int v = edge[i].v;
            if (!vis[v]) {
                q.push(v);
            }
        }
    }
    return false;
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &col[i]);
    }
    for (int i = 1; i < n; i++) {
        int u,v;
        scanf("%d%d", &u, &v);
        Insert(u,v);
        Insert(v,u);
    }
    int l = 0, r = n, ans;
    while (l <= r) {
        int mid = (l+r)>>1;
        if (check(mid)) {
            ans = mid;
            r = mid-1;
        } else {
            l = mid+1;
        }
    }
    printf("%d
", ans);
    return 0;
}

B题

扣6

https://blog.csdn.net/Cassie_zkq/article/details/101202727