2017-2018 ACM-ICPC, Asia Tsukuba Regional Contest

Problem A Secret of Chocolate Poles

Solved.

题意：有两种物品长度为1以及k， 求在长度为l 的箱子里放置物品的方案数， 每两个物品间有一个长度为1的空白

思路：$dp[i][0/1]$ $i$表示当前高度， $0/1$表示放不放

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn = 1e3 + 10;

int l, k;
ll dp[maxn][2];

int main()
{
    while(~scanf("%d %d", &l, &k))
    {
        memset(dp, 0, sizeof dp);
        dp[1][1] = 1;
        dp[k][1] = 1;
        for(int i = 1; i <= l; ++i)
        {
            dp[i + 1][0] += dp[i][1];
            dp[i + 1][1] += dp[i][0];
            dp[i + k][1] += dp[i][0];
        }
        ll ans = 0;
        for(int i = 1; i <= l; ++i) ans += dp[i][1];
        printf("%lld
", ans);
    }
    return 0;
}

Problem B Parallel Lines

Solved.

题意：有n个点， 将这些点两两匹配， 求最后平行条数

思路：DFS搜索， 复杂度为$O(15 cdot 13 cdot 11 cdot 9 cdot 7 cdot 5 cdot 3)$

#include<bits/stdc++.h>

using namespace std;

const int maxn = 4e3 + 10;

int gcd(int a,int b)
{
    return b == 0 ? a : gcd(b, a % b);
}

struct node{
    int x, y;
    node(){}
    node(int x, int y):x(x), y(y){}
}arr[maxn];

int n;
int ans;
int vis[maxn];
int G[maxn][maxn];
int X[maxn][maxn], Y[maxn][maxn];

void DFS(int cnt, int res)
{
    if(cnt + 2 > n) 
    {
        ans = max(ans, res);
        return ;
    }
    int pos1 = -1;
    for(int i = 1; i <= n; ++i) if(!vis[i])
    {
        pos1 = i;
        vis[i] = 1;
        break;
    }
    for(int i = 1; i <= n; ++i) if(!vis[i])
    {
        int pos2 = i;
        vis[i] = 1;
        int tmp = res;
        int dx = X[pos1][pos2];
        int dy = Y[pos1][pos2];
        tmp += G[dx][dy];
        G[dx][dy]++;
        DFS(cnt + 2, tmp);
        G[dx][dy]--;
        vis[pos2] = 0;
    }
    vis[pos1] = 0;
}


int main()
{
    while(~scanf("%d", &n))
    {
        memset(vis, 0, sizeof vis);
        for(int i = 1; i <= n; ++i) scanf("%d %d", &arr[i].x, &arr[i].y);
        for(int i = 1; i <= n; ++i) 
        {
            for(int j = i + 1; j <= n; ++j)
            {
                int dx = arr[j].x - arr[i].x;
                int dy = arr[j].y - arr[i].y;
                int GCD = gcd(dx, dy);
                dx /= GCD;
                dy /= GCD;
                dx += 2000;
                dy += 2000;
                X[i][j] = dx;
                Y[i][j] = dy;
            }
        }
        ans = 0;
        DFS(0, 0);
        printf("%d
", ans);
    }
    return 0;
}

Problem C Medical Checkup

Solved.

题意：有$n$个人去做体检，体检项目无限个，每个人完成一个项目的时间为$h_i$,按顺序做，没轮到就排队 求时刻$t$的时候每个人完成了多少个项目或者正在完成或者正在排队的也要算上

思路：如果$h_i >= h_{i - 1}$ 那么这个人去做，不会有等待时间，否则第一个项目等完后，考虑第二个的时候，需要等待$h_{i - 1} - h_i$的时间，加上自己完成的时间 刚好是$h_{i - 1}$

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 100010
int n, t, a[N];

int main()
{
    while (scanf("%d%d", &n, &t) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", a + i);
        ll res = 0;
        ll tot = 0;
        for (int i = 1; i <= n; ++i)
        {
            tot += a[i];
            res = 1;
            a[i] = max(a[i], a[i - 1]); 
            if (tot <= t + 1)
            {
                ll now = t - tot + 1;
                res += now / a[i] + (now % a[i] != 0);
            }
            printf("%lld
", res);
        }
    }
    return 0;
}

Problem E Black or White

Solved.

题意：有两个字符串$s$和$t$, 字符只由'B'和'W'组成，操作时选取一段长度不超过$k$的子段，将这一段全染成'B'或者'W'，求s -> t 最少操作数

思路：考虑是否跟前面的一起做，转移方程就是$dp[i] = Min_{j + k >= i}(dp[j - 1] + f(j, i))$

$dp[i]$表示处理到第$i$位的最少操作

线段树优化即可。

#include <bits/stdc++.h>
using namespace std;

#define N 500010
int n, k;
char a[N], b[N];
int f[N];

namespace SEG
{
    struct node
    {
        int Min[2], lazy[2];
        void init()
        {
            memset(Min, 0, sizeof Min);
            memset(lazy, 0, sizeof lazy);
        }
        void add(int x, int vis)
        {
            Min[vis] += x;
            lazy[vis] += x;
        }
        node operator + (const node &other) const
        {
            node res; res.init();
            for (int i = 0; i < 2; ++i)
                res.Min[i] = min(Min[i], other.Min[i]);
            return res;
        }
    }a[N << 2], res;
    void init()
    {
        memset(a, 0, sizeof a);
    }
    void pushdown(int id)
    {
        for (int i = 0; i < 2; ++i)
            if (a[id].lazy[i])
            {
                int &x = a[id].lazy[i];
                a[id << 1].add(x, i);
                a[id << 1 | 1].add(x, i);
                x = 0;
            }
    }
    void update(int id, int l, int r, int ql, int qr, int v, int vis)
    {
        if (qr < ql) return;
        if (l >= ql && r <= qr)
        {
            a[id].add(v, vis);
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(id);
        if (ql <= mid) update(id << 1, l, mid, ql, qr, v, vis);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr, v, vis);
        a[id] = a[id << 1] + a[id << 1 | 1];
    }
    void query(int id, int l, int r, int ql, int qr)
    {
        if (qr < ql) return; 
        if (l >= ql && r <= qr)
        {
            res = res + a[id];
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(id);
        if (ql <= mid) query(id << 1, l, mid, ql, qr);
        if (qr > mid) query(id << 1 | 1, mid + 1, r, ql, qr);
    }
}
// 0 all turn B
// 1 all turn W

int main()
{
    while (scanf("%d%d", &n, &k) != EOF)
    {
        scanf("%s", a + 1);
        scanf("%s", b + 1);
        SEG::init();
        f[1] = (a[1] != b[1]);
        if (b[1] == 'W')
            SEG::update(1, 1, n, 1, 1, 1, 0);
        else
            SEG::update(1, 1, n, 1, 1, 1, 1);
        for (int i = 2; i <= n; ++i)
        {
            f[i] = f[i - 1] + (a[i] != b[i]);
            for (int j = 0; j < 2; ++j)
                SEG::update(1, 1, n, i, i, f[i - 1], j);
            int last = max(1, i - k + 1); 
//            printf("%d%c", last, " 
"[i == n]);
            // 0
            if (b[i] == 'W')
            {
                SEG::update(1, 1, n, i, i, 1, 0);
                if (b[i - 1] != 'W')
                    SEG::update(1, 1, n, last, i - 1, 1, 0);
            }
            // 1
            if (b[i] == 'B')
            {
                SEG::update(1, 1, n, i, i, 1, 1);
                if (b[i - 1] != 'B')
                    SEG::update(1, 1, n, last, i - 1, 1, 1);
            }
            for (int j = 0; j < 2; ++j)
                SEG::res.Min[j] = (int)1e9;
            SEG::query(1, 1, n, last, i);
            for (int j = 0; j < 2; ++j)
                f[i] = min(f[i], SEG::res.Min[j] + 1);
//            printf("%d %d %d
", SEG::res.Min[0], SEG::res.Min[1], f[i]);
//            for (int j = 0; j < 2; ++j)
//                SEG::res.Min[j] = (int)1e9;
//            SEG::query(1, 1, n, i, i);
//            printf("%d %d
", SEG::res.Min[0], SEG::res.Min[1]);
        }
        printf("%d
", f[n]);
    }
    return 0;
}

Problem H Homework

Solved.

题意：有两种作业， 第一种作业有$m$种， 第二种作业有$n-m$种，每个作业有自己的startTime以及endTime， 每天选择一个集合做作业， 求最后能完成的最大值和最小值。

思路：

最大值很显然可以用最大流。

对于最小值， 可以将A类作业和源点相连以及自身对应的时间起点相连， B类作业和汇点相连以及自身对应的时间的终点相连，跑最小割。

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int INF = 0x3f3f3f3f;
const int maxn = 1e6 + 10;

struct Edge{
    int to, flow, nxt;
    Edge(){}
    Edge(int to, int nxt, int flow):to(to), nxt(nxt), flow(flow){}
}edge[maxn << 2];

struct node{
    int si, ti;
    node(){}
    node(int si, int ti):si(si), ti(ti){}
}arr[maxn];

int head[maxn], dep[maxn];

int S, T;
int n, m, tot;

void Init()
{
    memset(head, -1, sizeof head);
    tot = 0;
}

void addedge(int u,int v, int w, int rw = 0)
{
    edge[tot] = Edge(v, head[u], w); head[u] = tot++;
    edge[tot] = Edge(u, head[v], rw); head[v] = tot++;
}

bool BFS()
{
    memset(dep, -1, sizeof dep);
    queue<int>q;
    q.push(S);
    dep[S] = 1;
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = edge[i].nxt)
        {
            if(edge[i].flow && dep[edge[i].to] == -1)
            {
                dep[edge[i].to] = dep[u] + 1;
                q.push(edge[i].to);
            }
        }
    }
    return dep[T] < 0 ? 0 : 1;
}

int DFS(int u,int f)
{
    if(u == T || f == 0) return f;
    int w, used = 0;
    for(int i = head[u]; ~i; i = edge[i].nxt)
    {
        if(edge[i].flow && dep[edge[i].to] == dep[u] + 1)
        {
            w = DFS(edge[i].to, min(f - used, edge[i].flow));
            edge[i].flow -= w;
            edge[i ^ 1].flow += w;
            used += w;
            if(used == f) return f;    
        }
    }
    if(!used) dep[u] = -1;
    return used;
}

int Dicnic()
{
    int ans = 0;
    while(BFS())
    {
        ans += DFS(S, INF);
    }
    return ans;
}

int in[maxn], out[maxn], homework[maxn];

int main()
{
    while(~scanf("%d %d", &n, &m))
    {
        Init();
        for(int i = 1; i <= n; ++i) scanf("%d %d", &arr[i].si, &arr[i].ti);
        int cnt = 0;
        S = cnt++;
        for(int i = 1; i <= 400; ++i) in[i] = cnt++, out[i] = cnt++;
        for(int i = 1; i <= n; ++i) homework[i] = cnt++;
        T = cnt++;
        for(int i = 1; i <= n; ++i) addedge(S, homework[i], 1);
        for(int i = 1; i <= n; ++i) for(int j = arr[i].si; j <= arr[i].ti; ++j)
        {
            addedge(homework[i], in[j], 1);
        }
        for(int i = 1; i <= 400; ++i) addedge(in[i], out[i], 1);
        for(int i = 1; i <= 400; ++i) addedge(out[i], T, 1);
        int ans1 = Dicnic();
        
        Init();
        for(int i = 1; i <= m; ++i)
        {
            addedge(S, homework[i], 1);
            for(int j = arr[i].si; j <= arr[i].ti; ++j)
            {
                addedge(homework[i], in[j], 1);
            }
        } 
        for(int i = 1; i <= 400; ++i) addedge(in[i], out[i], 1);
        for(int i = m + 1; i <= n; ++i)
        {
            addedge(homework[i], T, 1);
            for(int j = arr[i].si; j <= arr[i].ti; ++j)
            {
                addedge(out[j], homework[i], 1);
            }
        }
        int ans2 = Dicnic();
        printf("%d
%d
", ans1, ans2);
    }
    return 0;
}

Problem I Starting a Scenic Railroad Service

Solved.

题意：求两种卖票方案需要提供的座位数。

思路：

对于第二种答案， 很显然可以用差分，求最大值得到。

对于第一种答案， 枚举在每个人， 求每个人上车前已经下车以及下车前还没上车的人数， 剩余的人数就是保证这个人上车有座位的座位数， 扫一遍求最大值即可。

#include<bits/stdc++.h>

using namespace std;

const int maxn = 2e5 + 10;

struct node{
    int l, r;
    node(){}
    node(int l,int r):l(l), r(r){}
}arr[maxn];

int n;
int ans1, ans2;
int sum[maxn];
int brr[maxn], crr[maxn];

int main()
{
    while(~scanf("%d", &n))
    {
        memset(sum, 0, sizeof sum);
        ans1 = ans2 = 0;
        for(int i = 1; i <= n; ++i)
        {
            scanf("%d %d", &arr[i].l, &arr[i].r);
            arr[i].r--;
            brr[i] = arr[i].r;
            crr[i] = arr[i].l;
            sum[arr[i].l]++, sum[arr[i].r + 1]--;
        }
        for(int i = 1; i < maxn; ++i)
        {
            sum[i] += sum[i - 1];
            ans1 = max(ans1, sum[i]);
        }
        sort(brr + 1, brr + 1 + n);
        sort(crr + 1, crr + 1 + n);
        for(int i = 1; i <= n; ++i)
        {
            int L = lower_bound(brr + 1, brr + 1 + n, arr[i].l) - brr;
            int R = upper_bound(crr + 1, crr + 1 + n, arr[i].r) - crr;
            R--;
            int tmp = n - (L - 1) - (n - R);
            ans2 = max(ans2, tmp);
        }
        printf("%d %d
", ans2, ans1);
    }
    return 0;
}