【Codeforces Round #364 (Div. 2)】

B

题目大意

向 $n * n$的棋盘中放m个车，每次询问安全格子数

---

统计不安全的行数和列数
那么$安全格子数 = 不安全列数 * n + 不安全行数 * n - 不安全列数 * 不安全行数$

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAXN = 100000 + 5;
bool useh[MAXN],usel[MAXN];
long long sumh,suml;
long long n,m;
long long x,y;
int main()
{
    scanf("%I64d %I64d",&n,&m);
    for(int i = 1;i <= m;i ++)
    {
        scanf("%I64d %I64d",&x,&y);
        if(!useh[x])
            useh[x] = true,sumh ++;
        if(!usel[y])
            usel[y] = true,suml ++;
        printf("%I64d ",n * n - n * sumh - n * suml + sumh * suml);
    }
    puts("");
    return 0;
}

C

题目大意

求原串的最短子串要求包含原串中的所有字母

---

尺取法，当然二分长度+前缀和也行

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cctype>
using namespace std;
const int MAXN = 100000 + 5;
int n,need;
int use[256];
char num[MAXN];
char tmp[MAXN];
int cqf()
{
    int l = -1,r = 0;
    int len = n,ans = 0;
    memset(use,0,sizeof(use));
    while(true)
    {
        while(r <= n && ans < need)
            ans += !(use[num[++ r]] ++);
        if(ans < need)
            break;
        len = min(len,r - l + 1);
        ans -= !(-- use[num[l ++]]);
    }
    return len;
}
int main()
{
    scanf("%d",&n);
    gets(tmp);
    gets(num + 1);
    for(int i = 1;i <= n;i ++)
    {
        need += !use[num[i]];
        use[num[i]] = true;
    }
    printf("%d\n",cqf());
    return 0;
}

D

题目大意

n个人要走过l的距离，可以坐车也可以走路，坐车比走路快，每个人只能坐一次车，求所有人都到达中点的最短时间

---

刚开始打了个模拟，发现过不了样例
于是就开始想……
才发现没必要一次把人送到头……
最好的时候就是送到半路上把他丢下，然后让他自己走23333
什么是最好的呢？
恰好大家一起到，没人等的话就是最好的
恩呢
可是我怎么知道大家一起到什么时间呢？
换句话说，我怎么知道答案呢？
二分！
嗯~
怎么验证呢？
让每个人都恰好到终点不就行了

有
$t_1 + t_2 = Kill_T - T$
其中，$t_1$表示人走的时间，$t_2$表示车走的时间，$Kill_T$表示限定的时间，$T$表示总时间
并且有

$$t_1 = \frac{L - S_x}{v_1}$$

$$t_2 = \frac{S_x - X} {v_2}$$
其中 $S_x$是Stop_x，车停下的坐标， $X$ 是步行的人的坐标
然后整个之中不知道的变量就只有$S_x$了，于是可以解，
通分移项，解之得！
$$\frac {L - S_x}{v_1} + \frac{S_x - X}{v_2} = Kill_T - T$$
$$\frac{(L - S_x) * v_2 + {(S_x - X)} * v_1}{v_1 * v_2} = Kill_T - T$$
$$(L * v_2) - (X * v_1) + S_x * (v_1 - v_2) = (Kill_T - T) * v_1 * v_2$$
$$S_x * (v_1 - v_2) = (Kill_T - T) * v_1 * v_2 - (L * v_2) + (X * v_1)$$
$$S_x = \frac{(Kill_T - T) * v_1 * v_2 - (L * v_2) + (X * v_1)}{(v_1 - v_2)}$$

那么相应的也就可以处理了

//这是过不了样例的贪心
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
double n,L,v1,v2,k;
int main()
{
    scanf("%lf %lf %lf %lf %lf",&n,&L,&v1,&v2,&k);
    double people = n;
    double T = 0;
    double x = 0;//步行的人的位置 
    while(true)
    {
        people -= k;
        double t = (L - x)/v2;
        T += t;
        if(people <= 0)
        {
            printf("%.6lf\n",T);
            return 0;
        }
        x += v1 * t;
        t = (L - x) / (v1 + v2);
        T += t;
        x += v1 * t;
    }
    return 0;
}

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
double n,L,v1,v2,k;
bool can(double kill_T)
{
    double people = n;
    double T = 0;
    double x = 0;//步行的人的位置 
    while(people > 0)
    {
        people -= k;
        double stop_x = (v1 * v2 * (kill_T - T) + v1 * x - v2 * L) / (v1 - v2);
        double t = (stop_x - x) / v2;
        T += t;
        x += t * v1;
        if(people <= 0)
            break;
        t = (stop_x - x) / (v1 + v2);
        x += t * v1;
        T += t;
    }
    return T <= kill_T;
}
double diver()
{
    double l = 0,r = 1e9;
    double ans = 0;
    for(int i = 1;i <= 100;i ++)
    {
        double mid = (l + r) / 2;
        if(can(mid))
            ans = mid,r = mid;
        else
            l = mid;
    }
    return ans;
}
int main()
{
    scanf("%lf %lf %lf %lf %lf",&n,&L,&v1,&v2,&k);
    printf("%lf",diver());
    return 0;
}

E

题目大意

给你一棵树，还有偶数个指定点，让他们两两分组，最大化$\sum dis(u,v)$

---

对于每一条边，他对答案的贡献是$min(sz[u],m*2 - sz[u])$
为什么？
因为对于每一条边，我们要尽量的让两边的节点配对（多经过几次）
嗯

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAXN = 200000 + 5;
int n,m;
struct edge
{
    int f,t;
}l[MAXN << 1];
int first[MAXN],next[MAXN << 1],tot;
void init()
{
    memset(first,0xfff,sizeof(first));
    tot = 0;
    return;
}
void build(int f,int t)
{
    l[++tot] = (edge){f,t};
    next[tot] = first[f];
    first[f] = tot;
    return;
}
bool use[MAXN];
int sz[MAXN];
int deep[MAXN];
long long ans = 0;
void dfs(int x,int f)
{
    deep[x] = deep[f] + 1;
    if(use[x])
        sz[x] = 1;
    for(int i = first[x];i != -1;i = next[i])
    {
        int v = l[i].t;
        if(v == f)
            continue;
        dfs(v,x);
        ans += min(sz[v],m - sz[v]);//直接在这里统计好啦
        sz[x] += sz[v];
    }
    return;
}
int x;
int f,t,v;
int main()
{
    init();
    scanf("%d %d",&n,&m);
    m <<= 1;
    for(int i = 1;i <= m;i ++)
    {
        scanf("%d",&x);
        use[x] = true;
    }
    for(int i = 1;i < n;i ++)
    {
        scanf("%d %d",&f,&t);
        build(f,t);
        build(t,f);
    }
    dfs(1,0);
    printf("%I64d\n",ans);
    return 0;
}

WA的原因是longlong和统计答案的方式