2017 ACM-ICPC World Finals - Rapid City

希望一年更比一年水

 

Secret Chamber at Mount Rushmore

签到题，搞出可达矩阵就可以了

#include <bits/stdc++.h>
using namespace std;
int d[26][26];

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    for(int i = 0; i < 26; ++i) d[i][i] = 1;
    for(int i = 1; i <= m; ++i) {
        char a[11], b[11];
        scanf("%s %s", a, b);
        d[(a[0] - 'a')][(b[0] - 'a')] = 1;
    }
    for(int i = 0; i < 26; ++i)
        for(int j = 0; j < 26; ++j)
            for(int k = 0; k < 26; ++k)
                d[j][k] |= d[j][i] & d[i][k];
    for(int i = 1; i <= n; ++i) {
        char a[111], b[111];
        scanf("%s %s", a, b);
        int len1 = strlen(a), len2 = strlen(b), ok = 1;
        if(len1 != len2) ok = 0;
        else for(int j = 0; j < len1; ++j) {
            if(!d[a[j] - 'a'][b[j] - 'a']) {
                ok = 0; break;
            }
        }
        puts(ok ? "yes" : "no");
    }
    return 0;
}

 

Need for Speed

又一签到题，二分答案判断总时间是否相等，注意速度不能变负

#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int d[1111], s[1111];

int main() {
    int n, t;
    double l = -1e18, r = 1e18;
    scanf("%d %d", &n, &t);
    for(int i = 1; i <= n; ++i) {
        scanf("%d %d", d + i, s + i);
        l = max(l, -1.0 * s[i]);
    }
    while(r - l > eps) {
        double m = (l + r) / 2;
        double sumt = 0;
        for(int i = 1; i <= n; ++i)
            sumt += d[i] / (s[i] + m);
        if(sumt > t) l = m;
        else r = m;
    }
    printf("%.8f\n", l);
    return 0;
}

 

Posterize

好像比较正常是一个n3的dp但是我失去理智n4就过了

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int r[266], p[266], id[266];
ll f[266][266], g[266][266];
const ll inf = 1e18;

bool cmp(int i, int j) {
    return r[i] < r[j];
}

int main() {
    int d, k;
    scanf("%d %d", &d, &k);
    for(int i = 1; i <= d; ++i) {
        scanf("%d %d", r + i, p + i);
        id[i] = i;
    }
    sort(id + 1, id + 1 + d, cmp);
    for(int i = 0; i < 266; ++i)
        for(int j = 0; j < 266; ++j)
                f[i][j] = inf;
    f[0][0] = 0;
    for(int i = 0; i <= 255; ++i) {
        memcpy(g, f, sizeof(g));
        for(int j = 0; j <= d; ++j) {
            for(int l = 0; l < k; ++l) {
                if(g[j][l] == inf) continue;
                ll sum = 0;
                for(int q = 1; j + q <= d; ++q) {
                    int x = id[j + q];
                    sum += 1ll * p[x] * (r[x] - i) * (r[x] - i);
                    f[j + q][l + 1] = min(f[j + q][l + 1], g[j][l] + sum);
                }
            }
        }
    }
    printf("%lld", f[d][k]);
    return 0;
}

 

Mission Improbable

好像最大匹配就可以了但是我失去理智最大权匹配就过了

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int a[111][111], rmax[111], cmax[111];

// SPFA_min_cost_flow
const ll inf = 1e18;
const int maxn = 6e4;
const int maxm = 1e6;
int cnt, h[maxn];
struct edge {
    int to, pre, cap, cost;
} e[maxm << 1];
void init() {
    cnt = 0;
    memset(h, -1, sizeof(h));
}
void add(int from, int to, int cap, int cost) {
    e[cnt].pre = h[from];
    e[cnt].to = to;
    e[cnt].cap = cap;
    e[cnt].cost = cost;
    h[from] = cnt;
    cnt++;
}
ll dist[maxn];
int vis[maxn];
int pv[maxn], pe[maxn];
ll min_cost_flow(int s, int t, int f) {
    ll ret = 0;
    while (f > 0) {
        memset(vis, 0, sizeof(vis));
        fill(dist, dist + maxn, inf);
        dist[s] = 0;
        queue<int> q;
        q.push(s);
        while (!q.empty()) {
            int v = q.front();
            q.pop();
            vis[v] = 0;
            for (int i = h[v]; i >= 0; i = e[i].pre) {
                int to = e[i].to, cap = e[i].cap;
                ll cost = e[i].cost;
                if (cap > 0 && dist[to] > dist[v] + cost) {
                    pv[to] = v, pe[to] = i;
                    dist[to] = dist[v] + cost;
                    if (!vis[to]) q.push(to);
                    vis[to] = 1;
                }
            }
        }

        if (dist[t] > 0) return ret; // modify here

        int d = f;
        for (int v = t; v != s; v = pv[v])
            d = min(d, e[pe[v]].cap);
        f -= d;
        ret += d * dist[t];
        for (int v = t; v != s; v = pv[v]) {
            e[pe[v]].cap -= d;
            e[pe[v] ^ 1].cap += d;
        }
    }
    return ret;
}

int main() {
    int r, c;
    scanf("%d %d", &r, &c);
    ll ans = 0;
    for(int i = 1; i <= r; ++i) {
        for(int j = 1; j <= c; ++j) {
            scanf("%d", &a[i][j]);
            if(a[i][j]) ans += a[i][j] - 1;
        }
    }
    init();
    int S = r + c + 1, T = S + 1, id = T;
    for(int i = 1; i <= r; ++i) {
        for(int j = 1; j <= c; ++j) {
            rmax[i] = max(rmax[i], a[i][j]);
        }
        if(rmax[i]) {
            ans -= rmax[i] - 1;
            add(S, i, 1, 1 - rmax[i]);
            add(i, S, 0, rmax[i] - 1);
        }
    }
    for(int j = 1; j <= c; ++j) {
        for(int i = 1; i <= r; ++i) {
            cmax[j] = max(cmax[j], a[i][j]);
        }
        if(cmax[j]) {
            ans -= cmax[j] - 1;
            add(r + j, T, 1, 0);
            add(T, r + j, 0, 0);
        }
    }
    for(int i = 1; i <= r; ++i) {
        for(int j = 1; j <= c; ++j) {
            if(a[i][j] && rmax[i] == cmax[j]) {
                ++id;
                add(i, id, 1, 0), add(id, i, 0, 0);
                add(id, r + j, 1, 0), add(r + j, id, 0, 0);
            }
        }
    }
    printf("%lld\n", ans - min_cost_flow(S, T, 1e9));
    return 0;
}

 

Visual Python++

从上到下扫描线每次匹配最右的不然肯定重叠了，最后检查一遍，注意要处理一下同一行内的重叠

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int r[maxn], c[maxn], ans[maxn];
vector<int> bx, by, row[maxn];
map<int, int> col;
map<int, int> :: iterator it;

typedef pair<int, int> pii;
vector<pii> ins[maxn], del[maxn];
set<pii> seg, rseg;
set<pii> :: iterator itl, itr;
inline pii re(pii x) {
    return pii(-x.second, -x.first);
}

int main() {
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n + n; ++i) {
        scanf("%d %d", r + i, c + i);
        bx.push_back(r[i]);
        by.push_back(c[i]);
    }
    sort(bx.begin(), bx.end());
    bx.erase(unique(bx.begin(), bx.end()), bx.end());
    sort(by.begin(), by.end());
    by.erase(unique(by.begin(), by.end()), by.end());
    for(int i = 1; i <= n + n; ++i) {
        r[i] = lower_bound(bx.begin(), bx.end(), r[i]) - bx.begin() + 1;
        c[i] = lower_bound(by.begin(), by.end(), c[i]) - by.begin() + 1;
        row[r[i]].push_back(i);
    }
    int ok = 1;
    for(int i = 1; i <= bx.size(); ++i) {
        for(int j = 0; j < row[i].size(); ++j) {
            int x = row[i][j];
            if(x <= n) {
                if(col.find(c[x]) == col.end()) col[c[x]] = x;
                else ok = 0;
            }
            else {
                it = col.upper_bound(c[x]);
                if(col.empty() || it == col.begin()) ok = 0;
                else {
                    --it;
                    int y = (*it).second;
                    ans[y] = x;
                    ins[r[y]].emplace_back(pii(c[y], c[x]));
                    del[r[x]].emplace_back(pii(c[y], c[x]));
                    col.erase(it);
                }
            }
        }
    }
    if(ok) {
        for(int i = 1; i <= bx.size(); ++i) {
            sort(ins[i].begin(), ins[i].end());
            for(int j = 0; j < ins[i].size(); ++j) {
                if(j && ins[i][j].first <= ins[i][j - 1].second) ok = 0;
                seg.insert(ins[i][j]), rseg.insert(re(ins[i][j]));
                itr = seg.upper_bound(ins[i][j]);
                if(itr != seg.end()) {
                    pii tmp = *itr;
                    if(tmp.first <= ins[i][j].second) ok = 0;
                }
                itl = rseg.upper_bound(re(ins[i][j]));
                if(itl != seg.end()) {
                    pii tmp = *itl;
                    if(tmp.first <= re(ins[i][j]).second) ok = 0;
                }
            }
            sort(del[i].begin(), del[i].end());
            for(int j = 0; j < del[i].size(); ++j) {
                if(j && del[i][j].first <= del[i][j - 1].second) ok = 0;
                seg.erase(del[i][j]), rseg.erase(re(del[i][j]));
            }
        }
    }
    if(!ok) puts("syntax error");
    else for(int i = 1; i <= n; ++i) printf("%d\n", ans[i] - n);
    return 0;
}

 

Money for Nothing

首先只保留递减的点，然后决策单调性，就可以分治了

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 10;
int p[maxn], d[maxn], id[maxn];

bool cmp(int i, int j) {
    return d[i] < d[j];
}

ll ans;
vector<int> L, R;
inline ll cal(int i, int j) {
    return 1ll * (d[R[j]] - d[L[i]]) * (p[R[j]] - p[L[i]]);
}
void solve(int l1, int r1, int l2, int r2) {
    if(l2 > r2) return;
    int m2 = (l2 + r2) / 2;
    ll mx = -1e18, pos = -1;
    for(int i = l1; i <= r1; ++i) {
        if(d[L[i]] >= d[R[m2]]) continue;
        ll tmp = cal(i, m2);
        if(tmp > mx) mx = tmp, pos = i;
    }
    ans = max(mx, ans);
    if(l2 != r2) {
        if(pos == -1) solve(l1, r1, m2 + 1, r2);
        else solve(l1, pos, l2, m2 - 1), solve(pos, r1, m2 + 1, r2);
    }
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    for(int i = 1; i <= m + n; ++i) {
        scanf("%d %d", p + i, d + i);
        id[i] = i;
    }
    sort(id + 1, id + 1 + m, cmp);
    for(int i = 1; i <= m; ++i) {
        if(!L.empty() && p[L.back()] <= p[id[i]]) continue;
        L.push_back(id[i]);
    }
    sort(id + m + 1, id + m + 1 + n, cmp);
    for(int i = n + m; i >= m + 1; --i) {
        if(!R.empty() && p[R.back()] >= p[id[i]]) continue;
        R.push_back(id[i]);
    }
    reverse(R.begin(), R.end());
    solve(0, L.size() - 1, 0, R.size() - 1);
    printf("%lld\n", ans);
    return 0;
}

 

Airport Construction

枚举两个顶点，判断是否是在多边形内且中间没有别的顶点，是的话往两边延伸，比较麻烦的是碰到顶点的情况，更麻烦的是顶点的一边与延伸方向重合的情况……

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

typedef long double db;
const db eps=1e-6;
const db inf=1e18;
int sign(db k){
    if (k>eps) return 1; else if (k<-eps) return -1; return 0;
}
int cmp(db k1,db k2){return sign(k1-k2);}
int inmid(db k1,db k2,db k3){return sign(k1-k3)*sign(k2-k3)<=0;}// k3 在 [k1,k2] 内
struct point{
    db x,y;
    point operator + (const point &k1) const{return (point){k1.x+x,k1.y+y};}
    point operator - (const point &k1) const{return (point){x-k1.x,y-k1.y};}
    point operator * (db k1) const{return (point){x*k1,y*k1};}
    point operator / (db k1) const{return (point){x/k1,y/k1};}
    int operator == (const point &k1) const{return cmp(x,k1.x)==0&&cmp(y,k1.y)==0;}
    bool operator < (const point k1) const{
        int a=cmp(x,k1.x);
        if (a==-1) return 1; else if (a==1) return 0; else return cmp(y,k1.y)==-1;
    }
    db abs(){return sqrt(x*x+y*y);}
};
int inmid(point k1,point k2,point k3){return inmid(k1.x,k2.x,k3.x)&&inmid(k1.y,k2.y,k3.y);}
db cross(point k1,point k2){return k1.x*k2.y-k1.y*k2.x;}
db dot(point k1,point k2){return k1.x*k2.x+k1.y*k2.y;}
int checkLL(point k1,point k2,point k3,point k4){// 求直线 (L) 线段 (S)k1,k2 和 k3,k4 的交点
    return cmp(cross(k3-k1,k4-k1),cross(k3-k2,k4-k2))!=0;
}
point getLL(point k1,point k2,point k3,point k4){
    db w1=cross(k1-k3,k4-k3),w2=cross(k4-k3,k2-k3); return (k1*w2+k2*w1)/(w1+w2);
}
int intersect(db l1,db r1,db l2,db r2){
    if (l1>r1) swap(l1,r1); if (l2>r2) swap(l2,r2); return cmp(r1,l2)!=-1&&cmp(r2,l1)!=-1;
}
int checkSS(point k1,point k2,point k3,point k4){
    return intersect(k1.x,k2.x,k3.x,k4.x)&&intersect(k1.y,k2.y,k3.y,k4.y)&&
           sign(cross(k3-k1,k4-k1))*sign(cross(k3-k2,k4-k2))<=0&&
           sign(cross(k1-k3,k2-k3))*sign(cross(k1-k4,k2-k4))<=0;
}
int onS(point k1,point k2,point q){return inmid(k1,k2,q)&&sign(cross(k1-q,k2-k1))==0;}
int contain(vector<point>A,point q){ // 2 内部 1 边界 0 外部
    int pd=0; A.push_back(A[0]);
    for (int i=1;i<A.size();i++){
        point u=A[i-1],v=A[i];
        if (onS(u,v,q)) return 1; if (cmp(u.y,v.y)>0) swap(u,v);
        if (cmp(u.y,q.y)>=0||cmp(v.y,q.y)<0) continue;
        if (sign(cross(u-v,q-v))<0) pd^=1;
    }
    return pd<<1;
}

int main() {
    int n;
    scanf("%d", &n);
    vector<point> p(n);
    for(int i = 0; i < n; ++i) cin >> p[i].x >> p[i].y;
    double ans = 0;
    for(int i = 0; i < n; ++i) {
        for(int j = i + 1; j < n; ++j) {
            int ok = 1;
            for(int k = 0; k < n; ++k) {
                if(i == k && j == (k + 1) % n || j == k && i == (k + 1) % n) continue;
                if(checkSS(p[i], p[j], p[k], p[(k + 1) % n])) {
                    if(onS(p[i], p[j], p[k]) && onS(p[i], p[j], p[(k + 1) % n])) {ok = 0; break;}
                    point x = getLL(p[i], p[j], p[k], p[(k + 1) % n]);
                    if(x == p[i] || x == p[j]) continue;
                    ok = 0; break;
                }
            }
            point mid = (p[i] + p[j]) / 2;
            if(!contain(p, mid)) ok = 0;
            if(!ok) continue;
            vector<point> q;
            for(int k = 0; k < n; ++k) {
                if(checkLL(p[i], p[j], p[k], p[(k + 1) % n])) {
                    point x = getLL(p[i], p[j], p[k], p[(k + 1) % n]);
                    if(onS(p[k], p[(k + 1) % n], x)) {
                        if(x == p[k]) {
                            point& nxt = p[(k + 1) % n];
                            point& pre = p[(k + n - 1) % n];
                            if(sign(cross(p[j] - p[i], pre - p[i])) == 0) {
                                if(sign(dot(p[k] - pre, p[j] - p[i])) > 0 && sign(cross(p[j] - p[i], nxt - p[i])) > 0) q.push_back(x);
                                if(sign(dot(p[k] - pre, p[i] - p[j])) > 0 && sign(cross(p[i] - p[j], nxt - p[j])) > 0) q.push_back(x);
                            }
                            else {
                                if(sign(cross(p[j] - p[i], pre - p[i])) < 0 && sign(cross(p[j] - p[i], nxt - p[i])) > 0) q.push_back(x);
                                if(sign(cross(p[i] - p[j], pre - p[j])) < 0 && sign(cross(p[i] - p[j], nxt - p[j])) > 0) q.push_back(x);
                            }
                        }
                        else if(x == p[(k + 1) % n]) {
                            point& nxt = p[(k + 2) % n];
                            point& cur = p[(k + 1) % n];
                            if(sign(cross(p[j] - p[i], nxt - p[i])) == 0) {
                                if(sign(dot(nxt - cur, p[j] - p[i])) < 0 && sign(cross(p[j] - p[i], p[k] - p[i])) < 0) q.push_back(x);
                                if(sign(dot(nxt - cur, p[i] - p[j])) < 0 && sign(cross(p[i] - p[j], p[k] - p[j])) < 0) q.push_back(x);
                            }
                            else {
                                if(sign(cross(p[j] - p[i], nxt - p[i])) > 0 && sign(cross(p[j] - p[i], p[k] - p[i])) < 0) q.push_back(x);
                                if(sign(cross(p[i] - p[j], nxt - p[j])) > 0 && sign(cross(p[i] - p[j], p[k] - p[j])) < 0) q.push_back(x);
                            }
                        }
                        else q.push_back(x);
                    }
                }
            }
            db di = inf, dj = inf;
            for(int k = 0; k < q.size(); ++k) {
                di = min(di, (p[i] - q[k]).abs());
                dj = min(dj, (p[j] - q[k]).abs());
            }
            ans = max(ans, double((p[i] - p[j]).abs() + di + dj));
        }
    }
    printf("%.8f\n", ans);
    return 0;
}

 

Tarot Sham Boast

不会猜结论

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> v[11];
string str[11];
char ch[maxn];
int id[11];

int nxt[maxn];
inline void getnxt(int x) {
    nxt[0] = nxt[1] = 0;
    int l = str[x].length();
    for (int i = 1; i < l; i++) {
        int j = nxt[i];
        while (j && str[x][i] != str[x][j]) j = nxt[j];
        nxt[i + 1] = str[x][i] == str[x][j] ? j + 1 : 0;
    }
}

bool cmp(int i, int j) {
    int sz = min(v[i].size(), v[j].size());
    for(int k = 0; k < sz; ++k) if(v[i][k] != v[j][k]) return v[i][k] > v[j][k];
    if(v[i].size() != v[j].size()) return v[i].size() < v[j].size();
    return i < j;
}

int main() {
    int n, s;
    scanf("%d %d", &n, &s);
    for(int i = 1; i <= s; ++i) {
        scanf("%s", ch);
        str[i] = string(ch);
        getnxt(i);
        int l = str[i].length(), p = l;
        while(p) {
            p = nxt[p];
            if(l + l - p <= n) v[i].push_back(l + l - p);
        }
        id[i] = i;
    }
    sort(id + 1, id + 1 + s, cmp);
    for(int i = 1; i <= s; ++i) printf("%s\n", str[id[i]].c_str());
    return 0;
}

 

Replicate Replicate Rfplicbte

不会观察

#include <bits/stdc++.h>
using namespace std;
int f[333][333], g[333][333];

#define F(i, j) ((i < u || j < l) ? 0 : f[i][j])
#define G(i, j) ((i < u || j < l) ? 0 : g[i][j])
inline int check_rows(int u, int d, int l, int r) {
    for(int i = u; i <= d + 1; ++i) {
        for(int j = l; j <= r + 1; ++j) {
            g[i][j] = F(i - 1, j - 1);
            for(int di = -1; di <= 1; ++di) {
                for(int dj = -1; dj <= 1; ++dj) {
                    if(di == 1 && dj == 1) continue;
                    g[i][j] ^= G(i - 1 + di, j - 1 + dj);
                }
            }
        }
        if(g[i][r] || g[i][r + 1]) return i - 1;
    }
    return -1;
}
inline int check_cols(int u, int d, int l, int r) {
    for(int j = l; j <= r + 1; ++j) {
        for(int i = u; i <= d + 1; ++i) {
            g[i][j] = F(i - 1, j - 1);
            for(int di = -1; di <= 1; ++di) {
                for(int dj = -1; dj <= 1; ++dj) {
                    if(di == 1 && dj == 1) continue;
                    g[i][j] ^= G(i - 1 + di, j - 1 + dj);
                }
            }
        }
        if(g[d][j] || g[d + 1][j]) return j - 1;
    }
    return -1;
}
inline void shrink(int& u, int& d, int& l, int& r) {
    for(int i = u; i <= d; ++i) {
        int ok = 1;
        for(int j = l; j <= r; ++j)
            if(f[i][j]) ok = 0;
        if(ok) u++;
        else break;
    }
    for(int i = d; i >= u; --i) {
        int ok = 1;
        for(int j = l; j <= r; ++j)
            if(f[i][j]) ok = 0;
        if(ok) d--;
        else break;
    }
    for(int j = l; j <= r; ++j) {
        int ok = 1;
        for(int i = u; i <= d; ++i)
            if(f[i][j]) ok = 0;
        if(ok) l++;
        else break;
    }
    for(int j = r; j >= l; --j) {
        int ok = 1;
        for(int i = u; i <= d; ++i)
            if(f[i][j]) ok = 0;
        if(ok) r--;
        else break;
    }
}

int main() {
    int n, m;
    scanf("%d %d", &m, &n);
    for(int i = 1; i <= n; ++i) {
        char s[333];
        scanf("%s", s + 1);
        for(int j = 1; j <= m; ++j) f[i][j] = s[j] == '#';
    }
    int u = 1, d = n, l = 1, r = m;
    shrink(u, d, l, r);
    while(d > u && r > l) {
        int row = check_rows(u, d, l, r);
        if(row == -1) memcpy(f, g, sizeof(f));
        else {
            int col = check_cols(u, d, l, r);
            f[row][col] ^= 1;
            int t = check_rows(u, d, l, r);
            if(t == -1) memcpy(f, g, sizeof(f));
            else {f[row][col] ^= 1; break;}
        }
        shrink(u, d, l, r);
    }
    for(int i = u; i <= d; ++i) {
        for(int j = l; j <= r; ++j) putchar(f[i][j] ? '#' : '.');
        puts("");
    }
    return 0;
}