湖南多校对抗5.24

据说A,B,C题都比较水这里就不放代码了

 

D:Facility Locations

然而D题是一个脑经急转弯的题：有m行，n列，每个位置有可能为0，也可能不为0，问最多选K行是不是可以使得每一列都至少有一个0，其中代价c有个约束条件：These costs satisfy a locality property: for two clients j and j’ and two facilities i and i’, we have cij ≤ ci’j + ci’j’ + cij’ .

一看特别像是重复覆盖的模板，然而稍加分析就会发现由于上面约束的存在，那么任意两行之间的0的摆放要么完全相同，要么完全错位，所以最后只要找出任意k个完全错开的行，判断是不是每一列都有一个0就可以了= =

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf (-((LL)1<<40))
#define lson k<<1, L, (L + R)>>1
#define rson k<<1|1,  ((L + R)>>1) + 1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
#define dec(i, a, b) for(int i = a; i >= b; i --)
 
template<class T> T CMP_MIN(T a, T b) { return a < b; }
template<class T> T CMP_MAX(T a, T b) { return a > b; }
template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }
 
//typedef __int64 LL;
typedef long long LL;
const int MAXN = 51000;
const int MAXM = 110000;
const double eps = 1e-4;
LL MOD = 1000000007;
 
int n, m, k, x;
bool vis[110];
 
int main()
{
    while(~scanf("%d %d %d", &n, &m, &k)) {
        mem0(vis);
        int time = 0, col = 0;
        rep (i, 1, n) {
            int add = 0;
            rep (j, 1, m) {
                scanf("%d", &x);
                if(x || vis[j]) continue;
                if(!add) time ++;
                add = 1;
                vis[j] = 1, col ++;
            }
        }
        puts(col == m && time <= k ? "yes" : "no");
    }
    return 0;
}

 

E：Repeated Substrings 据说是一个后缀数组的最长公共前缀（LCP）的应用，

赛后又自己写了一遍后缀数组（其实是把模板打了一遍，模板见链接），终于还是把这题A了

题解见链接

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf (-((LL)1<<40))
#define lson k<<1, L, (L + R)>>1
#define rson k<<1|1,  ((L + R)>>1) + 1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
#define dec(i, a, b) for(int i = a; i >= b; i --)
  
template<class T> T CMP_MIN(T a, T b) { return a < b; }
template<class T> T CMP_MAX(T a, T b) { return a > b; }
template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }
  
//typedef __int64 LL;
typedef long long LL;
const int MAXN = 110000;
const int MAXM = 110000;
const double eps = 1e-4;
LL MOD = 1000000007;
  
struct SufArray {
    char s[MAXN];
    int sa[MAXN], t[MAXN], t2[MAXN], c[MAXN], n, m;
    int rnk[MAXN], height[MAXN];
    int mi[MAXN][20], idxK[MAXN];
  
    void init() {
        mem0(s);
        mem0(height);
    }
    void read_str() {
        gets(s);
        m = 128;
        n = strlen(s);
        s[n++] = ' ';
    }
    void build_sa() {
        int *x = t, *y = t2;
        rep (i, 0, m - 1) c[i] = 0;
        rep (i, 0, n - 1) c[x[i] = s[i]] ++;
        rep (i, 1, m - 1) c[i] += c[i - 1];
        dec (i, n - 1, 0) sa[--c[x[i]]] = i;
        for(int k = 1; k <= n; k <<= 1) {
            int p = 0;
            rep (i, n - k, n - 1) y[p++] = i;
            rep (i, 0, n - 1) if(sa[i] >= k) y[p++] = sa[i] - k;
            rep (i, 0, m - 1) c[i] = 0;
            rep (i, 0, n - 1) c[x[y[i]]] ++;
            rep (i, 0, m - 1) c[i] += c[i - 1];
            dec (i, n - 1, 0) sa[--c[x[y[i]]]] = y[i];
            swap(x, y);
            p = 1;
            x[sa[0]] = 0;
            rep (i, 1, n - 1) {
                x[sa[i]] = y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k] ? p - 1 : p++;
            }
            if(p >= n) break;
            m = p;
        }
    }
    void get_height() {
        int k = 0;
        rep (i, 0, n - 1) rnk[sa[i]] = i;
        rep (i, 0, n - 1) {
            if(k) k --;
            int j = sa[rnk[i] - 1];
            while(s[i + k] == s[j + k]) k ++;
            height[rnk[i]] = k;
        }
    }
    void rmq_init(int *a, int n) {
        rep (i, 0, n - 1) mi[i][0] = a[i];
        for(int j = 1; (1 << j) <= n; j ++) {
            for(int i = 0; i + (1<<j) - 1 < n; i ++) {
                mi[i][j] = min(mi[i][j - 1], mi[i + (1 << (j - 1))][j - 1]);
            }
        }
        rep (len, 1, n) {
            idxK[len] = 0;
            while((1 << (idxK[len] + 1)) <= len) idxK[len] ++;
        }
    }
    int rmq_min(int l, int r) {
        int len = r - l + 1, k = idxK[len];
        return min(mi[l][k], mi[r - (1 << k) + 1][k]);
    }
    void lcp_init() {
        get_height();
        rmq_init(height, n);
    }
    int get_lcp(int a, int b) {
        if(a == b) return n - a - 1;
        return rmq_min(min(rnk[a], rnk[b]) + 1, max(rnk[a], rnk[b]));
    }
    void solve() {
        get_height();
        LL ans = 0, pre = 0;
        rep (i, 1, n - 1) {
            if(height[i] > pre) ans += height[i] - pre;
            pre = height[i];
        }
        cout << ans << endl;
    }
};
  
int T;
SufArray sa;
  
int main()
{
    while(~scanf("%d%*c", &T)) while(T--){
        sa.init();
        sa.read_str();
        sa.build_sa();
        sa.solve();
    }
    return 0;
}
/**************************************************************
    Problem: 1632
    User: csust_Rush
    Language: C++
    Result: Accepted
    Time:880 ms
    Memory:13192 kb
****************************************************************/

 

F：Landline Telephone Network题意就是求一颗最小生成树，但是任意两个点之间的唯一路径上不能通过任何一个 坏点  ，题目告诉你哪些是坏点

其实就是先不管坏点，求一遍最小生成树，然后把坏点加进去（注意细节地方）

#include <stdio.h>
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <cstring>
#define mem0(a) memset(a, 0, sizeof(a))
#define rep(i,a, b) for(int i = a; i <= b; i ++)
using namespace std;
 
int fa[1100];
struct Edge {
    int u, v, w;
    Edge(int _u = 0, int _v = 0, int _w = 0) {
        u = _u; v = _v; w = _w;
    }
    bool operator < (const Edge &A) const {
        return w < A.w;
    }
}e[110000];
int n, m, p, x, b[1100], u, v, w;
int t[1100];
 
int findFa(int x) {
    return x == fa[x] ? x : fa[x] = findFa(fa[x]);
}
 
int main()
{
    //freopen("in.txt", "r", stdin);
    while(~scanf("%d %d %d", &n, &m, &p) && n) {
        mem0(b); mem0(t);
        rep (i, 1, n) fa[i] = i;
        rep (i, 1, p) scanf("%d", &x), b[x] = 1;
        rep (i, 1, m) {
            scanf("%d %d %d", &u, &v, &w);
            e[i] = Edge(u, v, w);
        }
        if(n == 2) {
            cout << w << endl;
            continue;
        }
        sort(e + 1, e + m + 1);
        int ans = 0;
        rep (i, 1, m) {
            u = e[i].u, v = e[i].v, w = e[i].w;
            if(b[u] || b[v]) continue;
            int x = findFa(u), y = findFa(v);
            if(x != y) {
                ans += w;
                fa[x] = y;
            }
        }
        int imposs = 0;
        rep (i, 1, m) {
            u = e[i].u, v = e[i].v, w = e[i].w;
            if(!(b[u] ^ b[v])) continue;
            t[u]++; t[v] ++;
            if(b[u] && t[u] >= 2) continue;
            if(b[v] && t[v] >= 2) continue;
            int x = findFa(u), y = findFa(v);
            if(x != y) {
                ans += w;
                fa[x] = y;
            }
        }
        int cnt = 0;
        rep (i, 1, n) if(findFa(fa[i]) == i) {cnt ++; }
        if(imposs || cnt > 1) puts("impossible");
        else cout << ans << endl;
    }
    return 0;
}
 
/**************************************************************
    Problem: 1633
    User: csust_Rush
    Language: C++
    Result: Accepted
    Time:84 ms
    Memory:2792 kb
****************************************************************/

 

GAquarium Tank简单计算几何

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf (-((LL)1<<40))
#define lson k<<1, L, (L + R)>>1
#define rson k<<1|1,  ((L + R)>>1) + 1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
#define dec(i, a, b) for(int i = a; i >= b; i --)
 
template<class T> T CMP_MIN(T a, T b) { return a < b; }
template<class T> T CMP_MAX(T a, T b) { return a > b; }
template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }
 
//typedef __int64 LL;
typedef long long LL;
const int MAXN = 110000;
const int MAXM = 110000;
const double eps = 1e-6;
LL MOD = 1000000007;
 
int n;
double D, L;
struct Point {
    double x, y;
    Point(double _x = 0, double _y = 0) {
        x = _x; y = _y;
    }
};
 
double cross(Point a, Point b) {
    return a.x * b.y - a.y * b.x;
}
 
struct Polygon {
    Point p[MAXN];
    int cnt;
    double get_area() {
        int pre = cnt;
        double ans = 0;
        rep (i, 1, cnt) {
            ans += cross(p[pre], p[i]);
            pre = i;
        }
        return fabs(ans / 2);
    }
 
}pol, po;
 
Point get_point(Point a, Point b, double y0) {
    if(fabs(a.x - b.x) < eps) return Point(a.x, y0);
    double bi = (y0 - a.y) / (b.y - a.y);
    return Point(a.x + bi * (b.x - a.x), a.y + bi * (b.y - a.y));
}
 
double find_area(double y0) {
    int cnt = 0, pre = po.cnt;
    rep (i, 1, po.cnt) {
        if((y0 - po.p[pre].y) * (y0 - po.p[i].y) <= 0) {
            pol.p[++cnt] = get_point(po.p[pre], po.p[i], y0);
        }
        if(po.p[i].y < y0) pol.p[++cnt] = po.p[i];
        pre = i;
    }
    pol.cnt = cnt;
    return pol.get_area();
}
 
int main()
{
    //FIN;
    while(~scanf("%d", &po.cnt)) {
        cin >> D >> L;
        L *= 1000;
        double mx_y = 0.0;
        rep (i, 1, po.cnt) {
            scanf("%lf %lf", &po.p[i].x, &po.p[i].y);
            mx_y = max(mx_y, po.p[i].y);
        }
        double low = 0.0, high = mx_y;
        while(high - low > eps) {
            double mid = (low + high) / 2.0;
            if(find_area(mid) * D < L) low = mid;
            else high = mid;
        }
        printf("%.2lf\n", low);
    }
    return 0;
}
 
/**************************************************************
    Problem: 1634
    User: csust_Rush
    Language: C++
    Result: Accepted
    Time:12 ms
    Memory:4920 kb
****************************************************************/

 

H：Restaurant Ratings

一个数位的简单DP，DP[i][j]表示i个人打j分的方案数

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf (-((LL)1<<40))
#define lson k<<1, L, (L + R)>>1
#define rson k<<1|1,  ((L + R)>>1) + 1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
#define dec(i, a, b) for(int i = a; i >= b; i --)
 
template<class T> T CMP_MIN(T a, T b) { return a < b; }
template<class T> T CMP_MAX(T a, T b) { return a > b; }
template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }
 
//typedef __int64 LL;
typedef long long LL;
const int MAXN = 51000;
const int MAXM = 110000;
const double eps = 1e-4;
LL MOD = 1000000007;
 
LL dp[110][110];
 
void init_dp(int n) {
    dp[0][0] = 1;
    rep (i, 1, n) {
        rep (j, 0, n) {
            rep (k, 0, j) {
                dp[i][j] += dp[i - 1][j - k];
            }
        }
    }
}
 
int n, a[110];
 
int main()
{
    init_dp(100);
    while(~scanf("%d", &n) && n) {
        int sum = 0;
        rep (i, 1, n) {
            scanf("%d", &a[i]);
            sum += a[i];
        }
        LL ans = 1;
        rep (i, 0, sum - 1) {
            ans += dp[n][i];
        }
        rep (i, 1, n) {
            rep (j, 0, a[i] - 1) {
                ans += dp[n - i][sum - j];
            }
            sum -= a[i];
        }
        cout << ans << endl;
    }
    return 0;
}
 
/**************************************************************
    Problem: 1635
    User: csust_Rush
    Language: C++
    Result: Accepted
    Time:16 ms
    Memory:1580 kb
****************************************************************/

 

I：Locked Treasure

据说是看样例找规律，然后发现ans=C(n, m-1)，不过也有类似的完美证明

 

J：Yet Satisfiability Again!

比赛时最后几分钟用暴力交了一发，发现AC了，赛后看其他人时间，大概都是暴利做的

最后干脆连题解都是用暴力啊= =

#include <stdio.h>
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <cstring>
#define mem0(a) memset(a, 0, sizeof(a))
#define rep(i,a, b) for(int i = a; i <= b; i ++)
using namespace std;
 
int t, n, m;
struct Node {
    int a[21], f[21], cnt;
    bool judge(int s) {
        int ans = 0, p = 0;
        while(p < cnt && !ans) {
            ans |= a[p] ^ (((1<<f[p]) & s) ? 1 : 0);
            p ++;
        }
        return ans;
    }
}mt[110];
char s[111100];
 
void handle(char *s, int id) {
    int len = strlen(s), cnt = 0;
    rep (i, 0, len - 1) {
        if(s[i] == 'X') {
            int num = 0, p = i;
            while(isdigit(s[++p])) num = num * 10 + s[p] - '0';
            mt[id].a[cnt] = i > 0 && s[i - 1] == '~';
            mt[id].f[cnt++] = num - 1;
        }
    }
    mt[id].cnt = cnt;
}
 
int main()
{
    //freopen("in.txt", "r", stdin);
    while(cin >> t) while(t--) {
        scanf("%d %d", &n, &m);
        gets(s);
        rep (i, 1, m) {
            gets(s);
            handle(s, i);
        }
        int ok = 0, h = (1 << n) - 1;
        rep (s, 0, h) {
            int p = 1;
            rep (i, 1, m) {
                p &= mt[i].judge(s);
                if(!p) break;
            }
            ok |= p;
            if(ok) {
                break;
            }
        }
        if(ok) puts("satisfiable");
        else puts("unsatisfiable");
    }
    return 0;
}
 
/**************************************************************
    Problem: 1637
    User: csust_Rush
    Language: C++
    Result: Accepted
    Time:1768 ms
    Memory:1612 kb
****************************************************************/

 

K：Continued Fraction

做了两次了，第一次以为超LL，后来队友用BigInt（自己写的模板）过了

后来又听说LL可以过，再回头看自己代码，发现有用LL*LL，这必然超啊。。。改了后发现立马AC

#include <stdio.h>
#include <iostream>
#include <cmath>
#include <cstdlib>
using namespace std;
 
typedef long long LL;
 
int n, m;
LL a1[100], a2[100];
 
LL gcd(LL a, LL b) {
    return b == 0 ? a : gcd(b, a % b);
}
 
void dfs1(LL &a, LL &b, LL *arr, int i, int n)
{
    if(i >= n - 1) {
        a = 1; b = arr[i]; return ;
    }
    dfs1(a, b, arr, i + 1, n);
    LL tmp = a;
    a = b; b = arr[i] * b + tmp;
    LL g = gcd(a, b);
    a /= g; b /= g;
}
 
void add(LL A1, LL B1, LL A2, LL B2, LL &x, LL &y) {
    x = A1 * B2 + A2 * B1;
    y = B1 * B2;
    LL g = gcd(x, y);
    x /= g; y /= g;
}
void sub(LL A1, LL B1, LL A2, LL B2, LL &x, LL &y) {
    x = A1 * B2 - A2 * B1;
    y = B1 * B2;
    LL g = gcd(x, y);
    x /= g; y /= g;
}
void mul(LL A1, LL B1, LL A2, LL B2, LL &x, LL &y) {
    x = A1 * A2; y = B1 * B2;
    LL g = gcd(x, y);
    x /= g; y /= g;
}
void div(LL A1, LL B1, LL A2, LL B2, LL &x, LL &y) {
    x = A1 * B2; y = A2 * B1;
    LL g = gcd(x, y);
    x /= g; y /= g;
}
 
void print(LL x, LL y) {
    if (x > 0 && y < 0 || x < 0 && y > 0) {
        if (x % y != 0) cout<< x / y - 1 << " ";
        else {
            cout << x / y << endl;;
            return;
        }
        x = abs(y) - abs(x) % abs(y);
        print(abs(y), x);
        return ;
    }
    cout << x / y;
    if(x % y) {
        printf(" ");
        print(y, x % y);
    }
    else printf("\n");
}
 
int main()
{
    //freopen("in.txt", "r", stdin);
    int cas = 0;
    while(~scanf("%d %d", &n, &m)) {
        for(int i = 0; i < n; i ++) cin >> a1[i];
        for(int i = 0; i < m; i ++) cin >> a2[i];
        LL A1 = 0, B1 = 1, A2 = 0, B2 = 1;
        if (n > 1) dfs1(A1, B1, a1, 1, n);
        if (m > 1) dfs1(A2, B2, a2, 1, m);
        A1 = a1[0] * B1 + A1;
        A2 = a2[0] * B2 + A2;
        LL x, y;
        //printf("Case %d:\n", ++cas);
        add(A1, B1, A2, B2, x, y); print(x, y);
        sub(A1, B1, A2, B2, x, y); print(x, y);
        mul(A1, B1, A2, B2, x, y); print(x, y);
        div(A1, B1, A2, B2, x, y); print(x, y);
    }
    return 0;
}