The 2018 ACM-ICPC Asia Qingdao Regional Contest, Online Solution

A    Live Love

水。

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const ll MOD = (int)1e9 + 7;
const int maxn = (int)1e6 + 10;

int n, m;

inline void RUN()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d %d", &n, &m);
        int ans1 = m;
        int ans2 = (n) / (n - m + 1);
        printf("%d %d
", ans1, ans2);
    }
}

int main()
{
#ifdef LOCAL_JUDGE
    freopen("Text.txt", "r", stdin);
#endif // LOCAL_JUDGE

    RUN();

#ifdef LOCAL_JUDGE
    fclose(stdin);
#endif // LOCAL_JUDGE
    return 0;
}

B Red Black Tree

题意：有一个树，上面有红点和黑点，有边权，每个点的花费定义为它到离它最近的红点的距离，每次询问给出一些点，能够将这棵树中的一个黑点变为红点，使得这些点中的最大花费最小

思路：二分答案，符合条件的点不管，将不符合条件的点LCA求出来，变红，然后算距离

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

#define N 100010
#define ll long long
#define INFLL 0x3f3f3f3f3f3f3f3f

struct Edge
{
    int to, nx; ll w;
    inline Edge() {}
    inline Edge(int to, int nx, ll w) : to(to), nx(nx), w(w) {}
}edge[N << 1];

int t, n, m, q, k;
int isred[N], prered[N], head[N], arr[N], pos;
int rmq[N << 1], F[N << 1], P[N], deep[N], cnt; 
ll dist[N]; 

inline void Init()
{
    memset(head, -1, sizeof head); pos = 0;
    memset(isred, 0, sizeof isred);  deep[1] = 0;
}

inline void addedge(int u, int v, ll w)
{
    edge[++pos] = Edge(v, head[u], w); head[u] = pos;
}

struct ST
{
    int mm[N << 1];
    int dp[N << 1][20];
    inline void init(int n)
    {
        mm[0] = -1;
        for (int i = 1; i <= n; ++i)
        {
            mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
            dp[i][0] = i;
        }
        for (int j = 1; j <= mm[n]; ++j)
        {
            for (int i = 1; i + (1 << j) - 1 <= n; ++i)
            {
                dp[i][j] = rmq[dp[i][j - 1]] < rmq[dp[i + (1 << (j - 1))][j - 1]] ? dp[i][j - 1] : dp[i + (1 << (j - 1))][j - 1];
            }
        }
    }
    inline int query(int a, int b)
    {
        if (a > b) swap(a, b);
        int k = mm[b - a + 1];
        return rmq[dp[a][k]] <= rmq[dp[b - (1 << k) + 1][k]] ? dp[a][k] : dp[b - (1 << k) + 1][k];
    }
}st;

inline void DFS(int u, int pre, int prer)
{
    F[++cnt] = u;
    rmq[cnt] = deep[u];
    P[u] = cnt;
    prered[u] = prer;  
    for (int it = head[u]; ~it; it = edge[it].nx)
    {
        int v = edge[it].to;
        if (v == pre) continue;
        if (isred[v]) dist[v] = 0;
        else dist[v] = dist[u] + edge[it].w;
        deep[v] = deep[u] + 1;
        DFS(v, u, isred[v] ? v : prer);
        F[++cnt] = u;
        rmq[cnt] = deep[u];
    }
}

inline void Lca_Init(int root, int node_num)
{
    cnt = 0;
    DFS(root, root, 1);
    st.init(2 * node_num - 1);
}

inline int query_lca(int u, int v)
{
    return F[st.query(P[u], P[v])];
}

vector <int> v; 
inline bool check(ll mid)
{
    v.clear();
    for (int i = 1; i <= k; ++i)
    {
        if (dist[arr[i]] > mid)
            v.emplace_back(arr[i]);
    }
    if (v.empty()) return true; 
    int lca = v[0];
    for (int i = 1, len = v.size(); i < len; ++i)
        lca = query_lca(lca, v[i]);
    if (isred[lca]) return false;  
    for (auto it : v)
    {
        if (deep[lca] < deep[prered[it]]) return false; 
        else if (dist[it] - dist[lca] > mid) return false;  
    }
    return true;
}

inline void Run() 
{
    for (scanf("%d", &t); t--; )
    {
        scanf("%d%d%d", &n, &m, &q); Init();
        for (int i = 1, u; i <= m; ++i)
        {
            scanf("%d", &u);
            isred[u] = 1;
        }
        ll w;
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d%lld", &u, &v, &w);
            addedge(u, v, w); addedge(v, u, w);
        }
        Lca_Init(1, n);
        for (int qq = 1; qq <= q; ++qq)
        {
            scanf("%d", &k);
            for (int i = 1; i <= k; ++i) scanf("%d", arr + i); 
            if (k == 1)
            {
                puts("0");
                continue;
            }
            ll l = 0, r = INFLL, ans; 
            while (r - l >= 0)
            {
                ll mid = (l + r) >> 1;
                if (check(mid))
                {
                    ans = mid;
                    r = mid - 1;
                }
                else
                    l = mid + 1;
            }
            printf("%lld
", ans);
        }
    }
}

int main()
{
    #ifdef LOCAL  
        freopen("Test.in", "r", stdin); 
    #endif    
        
    Run();
    return 0;
}  

 愚蠢的倍增求LCA（排序一下）

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll MOD = (int)1e9 + 7;
const int maxn = (int)1e5 + 10;

const int DEG = 20;

struct Edge {
    int to, nxt;
    ll w;
    inline Edge(){}
    inline Edge(int to,int nxt,ll w):to(to),nxt(nxt),w(w){}
}edge[maxn << 1];

int head[maxn], tot;
int red[maxn];

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

inline void Init(int n)
{
    for (int i = 1; i <= n; ++i)
    {
        red[i] = 0;
        head[i] = -1;
    }
    tot = 0;
}

ll dis[maxn];
int fa[maxn][DEG];
int deg[maxn];
int pre[maxn];

inline void BFS(int root)
{
    queue<int>q;
    dis[root] = 0;
    deg[root] = 0;
    fa[root][0] = root;
    pre[root] = root;
    q.push(root);
    while (!q.empty())
    {
        int tmp = q.front();
        q.pop();
        for (int i = 1; i < DEG; ++i)
        {
            fa[tmp][i] = fa[fa[tmp][i - 1]][i - 1];
        }
        for (int i = head[tmp]; ~i; i = edge[i].nxt)
        {
            int v = edge[i].to;
            ll w = edge[i].w;
            if (v == fa[tmp][0]) continue;
            deg[v] = deg[tmp] + 1;
            fa[v][0] = tmp;
            if (red[v])
            {
                pre[v] = v;
            }
            else
            {
                pre[v] = pre[tmp];
            }
            if (red[v])
            {
                dis[v] = 0;
            }
            else
            {
                dis[v] = dis[tmp] + w;
            }
            q.push(v);
        }
    }
}

inline int LCA(int u, int v)
{
    if (deg[u] > deg[v]) swap(u, v);
    int hu = deg[u], hv = deg[v];
    int tu = u, tv = v;
    for (int det = hv - hu, i = 0; det; det >>= 1, ++i)
    {
        if (det & 1)
        {
            tv = fa[tv][i];
        }
    }
    if (tu == tv) return tu;
    for (int i = DEG - 1; i >= 0; --i)
    {
        if (fa[tu][i] == fa[tv][i]) continue;
        tu = fa[tu][i], tv = fa[tv][i];
    }
    return fa[tu][0];
}

int n, m, q, k;
int arr[maxn];

inline bool cmp(int a, int b)
{
    return dis[a] > dis[b];
}

inline bool check(ll mid)
{
    int root = arr[1];
    int cnt = 0;
    for (int i = 1; i <= k; ++i)
    {
        if (dis[arr[i]] > mid)
        {
            if (pre[root] != pre[arr[i]]) return false;
            root = LCA(root, arr[i]);
            cnt++;
        }
    }
    if (cnt == 1 || cnt == 0) return true;
    for (int i = 1; i <= k; ++i)
    {
        if (dis[arr[i]] > mid)
        {
            if (dis[arr[i]] - dis[root] > mid) return false;
        }
    }
    return true;
}

inline void RUN()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d %d %d", &n, &m, &q);
        Init(n);
        for (int i = 1; i <= m; ++i)
        {
            int u;
            scanf("%d", &u);
            red[u] = 1;
        }
        for (int i = 1; i < n; ++i)
        {
            int u, v;
            ll w;
            scanf("%d %d %lld", &u, &v, &w);
            addedge(u, v, w);
            addedge(v, u, w);
        }
        BFS(1);
        while (q--)
        {
            scanf("%d", &k);
            for (int i = 1; i <= k; ++i)
            {
                scanf("%d", arr + i);
            }
            if (k == 1)
            {
                puts("0");
                continue;
            }
            sort(arr + 1, arr + 1 + k, cmp);
            ll l = 0;
            ll r = INFLL;
            ll ans = 0;
            while (r - l >= 0)
            {
                ll mid = (r + l) >> 1;
                if (check(mid))
                {
                    r = mid - 1;
                    ans = mid;
                }
                else
                {
                    l = mid + 1;
                }
            }
            printf("%lld
", ans);
        }
    }
}

int main()
{
#ifdef LOCAL_JUDGE
    freopen("Text.txt", "r", stdin);
#endif // LOCAL_JUDGE

    RUN();

#ifdef LOCAL_JUDGE
    fclose(stdin);
#endif // LOCAL_JUDGE
    return 0;
}

C Halting Problem

题意：给出五种操作，机器从第一条命令开始，问是否能到n+1条命令。

思路：暴力，记录状态，若来到重复状态则输出No

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const ll MOD = (int)1e9 + 7;
const int maxn = (int)1e4 + 10;

int n, num;
int vis[maxn][260];
struct node {
    char op[10];
    int v, k;
}arr[maxn];

inline void RUN()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 0; j < 256; ++j)
            {
                vis[i][j] = 0;
            }
        }
        int flag = true;
        int s = 0;
        int now = 1;
        for (int i = 1; i <= n; ++i)
        {
            scanf("%s", arr[i].op);
            if (strcmp(arr[i].op,"add") == 0)
            {
                scanf("%d", &arr[i].v);
                arr[i].k = 0;
            }
            else
            {
                scanf("%d %d", &arr[i].v, &arr[i].k);
            }
        }
        while (1)
        {
            if (now == n + 1)
            {
                flag = true;
                break;
            }
            if (vis[now][s])
            {
                flag = false;
                break;
            }
            vis[now][s]++;
            if (strcmp(arr[now].op, "add") == 0)
            {
                s = (s + arr[now].v);
                if (s >= 256)s -= 256;
                now++;
            }
            else if (strcmp(arr[now].op, "beq") == 0)
            {
                if (s == arr[now].v)
                {
                    now = arr[now].k;
                }
                else
                {
                    now++;
                }
            }
            else if (strcmp(arr[now].op, "bne") == 0)
            {
                if (s != arr[now].v)
                {
                    now = arr[now].k;
                }
                else
                {
                    now++;
                }
            }
            else if (strcmp(arr[now].op, "blt") == 0)
            {
                if (s < arr[now].v)
                {
                    now = arr[now].k;
                }
                else
                {
                    now++;
                }
            }
            else if (strcmp(arr[now].op, "bgt") == 0)
            {
                if (s > arr[now].v)
                {
                    now = arr[now].k;
                }
                else
                {
                    now++;
                }
            }
        }
        puts(flag ? "Yes" : "No");
    }
}

int main()
{
#ifdef LOCAL_JUDGE
    freopen("Text.txt", "r", stdin);
#endif // LOCAL_JUDGE

    RUN();

#ifdef LOCAL_JUDGE
    fclose(stdin);
#endif // LOCAL_JUDGE
    return 0;
}

D Pixel Art

留坑。

E Infinite Parenthesis Sequence

留坑。

F Chaleur

留坑。

G Couleur

题意：每次标记一个数不可用，那么就将原数组分成多一段，然后找出子数组中异或最大。

思路：每次划分成两边，对小的那边暴力，可以用set 来找左界右界，map 来找出当前界中的值  multiset 找最大值

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

#define N 100010
#define M N * 30  
using ll = long long; 
using pii = pair <int, int>; 

int t, n;
set <int> s; 
multiset <ll> mst; 
map <pii, ll> mp; 
int arr[N], p[N];  
ll ans;

struct BIT 
{
    int a[N];  
    inline void update(int x)
    {  
        for (int i = x; i <= n; i += i & -i)
            ++a[i];
    }  
    inline int query(int x)
    { 
        int res = 0;
        for (int i = x; i > 0; i -= i & -i)
            res += a[i];
        return res;
    }  
}bit; 

struct chairman_tree
{
    int T[N], L[M], R[M], C[M], tot;
    inline int build(int l, int r)
    {
        int root = tot++;
        C[root] = 0;
        if (l < r)
        {
            int mid = (l + r) >> 1; 
            L[root] = build(l, mid);
            R[root] = build(mid + 1, r);
        }
        return root;
    }
    inline int update(int root, int pos)
    {
        int newroot = tot++, tmp = newroot;
        C[newroot] = C[root] + 1;
        int l = 1, r = n;
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (pos <= mid)
            {
                L[newroot] = tot++; R[newroot] = R[root];
                newroot = L[newroot], root = L[root];
                r = mid;
            }
            else
            {
                L[newroot] = L[root], R[newroot] = tot++;
                newroot = R[newroot], root = R[root];
                l = mid + 1; 
            }
            C[newroot] = C[root] + 1; 
        }
        return tmp;
    }
    inline int query(int left_root, int right_root, int pos, int vis)
    {
        int l = 1, r = n, res = 0;
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (pos <= mid)
            {
                left_root = L[left_root];
                right_root = L[right_root];
                r = mid;
            }
            else
            {
                res += C[L[left_root]] - C[L[right_root]];
                left_root = R[left_root];
                right_root = R[right_root];
                l = mid + 1;
            }
        }
        if (vis) res += C[left_root] - C[right_root];
        return res;   
    }
}ct; 

inline void Init()
{
    memset(bit.a, 0, sizeof bit.a); ct.tot = 0;
    s.clear(), mst.clear(), mp.clear(); ans = 0;
    s.emplace(0), s.emplace(n + 1);
    ct.T[n + 1] = ct.build(1, n); 
}

inline void Run()
{
    for (scanf("%d", &t); t--; )
    {
        scanf("%d", &n); Init();
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d", arr + i);
            bit.update(arr[i]);
            ans += i - bit.query(arr[i]);
        }
        for (int i = 1; i <= n; ++i) scanf("%d", p + i);
        for (int i = n; i >= 1; --i) ct.T[i] = ct.update(ct.T[i + 1], arr[i]);
        mp[pii(1, n)] = ans; mst.insert(ans);
        for (int i = 1; i <= n; ++i)
        {
            printf("%lld%c", ans, " 
"[i == n]);
            if (ans)
            {
                int id = int(ans ^ p[i]), l, r;
                l = *(--s.upper_bound(id)) + 1; 
                r = *(s.upper_bound(id)) - 1; s.insert(id);
                ll val = mp[pii(l, r)];
                mst.erase(mst.lower_bound(val));  
                mp.erase(pii(l, r)); 
                val -= id - l - ct.query(ct.T[l], ct.T[id], arr[id], 1);
                if (id - l < r - id) // goto left   
                {
                    for (int j = l; j <= id; ++j)
                        val -= ct.query(ct.T[id + 1], ct.T[r + 1], arr[j], 0);
                    ll vall = 0, valr = 0;
                    for (int j = l + 1; j < id; ++j)
                        vall += j - l - ct.query(ct.T[l], ct.T[j], arr[j], 1);
                    valr = val - vall;
                    mst.insert(vall), mst.insert(valr);
                    mp[pii(l, id - 1)] = vall; mp[pii(id + 1, r)] = valr;
                }
                else   // goto right                     
                {
                    for (int j = id + 1; j <= r; ++j)
                        val -= id - l + 1 - ct.query(ct.T[l], ct.T[id + 1], arr[j], 1);
                    ll vall = 0, valr = 0; 
                    for (int j = id + 1; j <= r; ++j)
                        valr += j - id - 1 - ct.query(ct.T[id + 1], ct.T[j], arr[j], 1);
                    vall = val - valr;
                    mst.insert(vall), mst.insert(valr);
                    mp[pii(l, id - 1)] = vall; mp[pii(id + 1, r)] = valr;
                }
                ans = *(mst.rbegin());
            }
        }
    }
}

int main()
{
    #ifdef LOCAL  
        freopen("Test.in", "r", stdin);
    #endif    

    Run();
    return 0;
}  

H Traveling on the Axis

题意：一个字符串表示当前点是红灯还是绿灯，灯一秒变一次，求$sum_{p = 0}^{n - 1}sum_{q = p +1}^{n} t(p, q)$

思路：前缀搞一搞

#include<bits/stdc++.h>

using namespace std;

char st[100000+10];
long long f[100000+10];
int main() {
    long long t,n,i,j,k;
    long long ans;
    scanf("%lld",&t);
    while (t--) {
        scanf("%s",st);
        n=strlen(st);
        f[1]=1; ans=0;
        for (i=1;i<n;++i) 
            if (st[i]==st[i-1]) f[i+1]=2;
            else f[i+1]=1;
        for (i=1;i<=n;++i) {
            ans+=(f[i])*i*(n-i+1);
            if (st[i-1]=='0') ans+=n-i+1;
            if (f[i]==2) ans-=n-i+1;
        }
        printf("%lld
",ans);
    }
    return 0;
}

J Press the Button

题意：周期性按灯，每按一次，如果灯本来是亮着就++， 求最后+了多少次

思路：记录lcm时间内的增加次数以及t%lcm时间内的增加次数。用两个时间节点记录两人下次按的时间，然后暴力跑出lcm以及t%lcm时间内的增加次数即可

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const ll MOD = (int)1e9 + 7;
const int maxn = (int)1e4 + 10;

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

ll a, b, c, d, v, t;

inline void RUN()
{
    int cas;
    scanf("%d", &cas);
    while (cas--)
    {
        scanf("%lld %lld %lld %lld %lld %lld", &a, &b, &c, &d, &v, &t);
        ll G = gcd(a, c);
        G = a * c / G;
        //cout << G << endl;
        ll res =0;
        ll res1 =  b - 1 + d;
        ll len = t / G;
        ll M = t % G;
        ll t1 = a;
        ll t2 = c;
        ll now = 0;
        while (t1 <= G && t2 <= G)
        {
            if (t1 < t2)
            {
                ll tmp = t1 - now;
                if (tmp > v)
                {
                    res += b - 1;
                    if (t1 <= M)
                    {
                        res1 += b - 1;
                    }
                }
                else
                {
                    res += b;
                    if (t1 <= M)
                    {
                        res1 += b;
                    }
                }
                now = t1;
                t1 += a;

            }
            else if (t1 > t2)
            {
                ll tmp = t2 - now;
                if (tmp > v)
                {
                    res += d - 1;
                    if (t2 <= M)
                    {
                        res1 += d - 1;
                    }
                }
                else
                {
                    res += d;
                    if (t2 <= M)
                    {
                        res1 += d;
                    }
                }
                now = t2;
                t2 += c;
            }
            else if (t1 == t2)
            {
                ll tmp = t1 - now;
                if (tmp > v)
                {
                    res += b + d - 1;
                    if (t1 <= M)
                    {
                        res1 += b + d - 1;
                    }
                }
                else
                {
                    res += b + d;
                    if (t1 <= M)
                    {
                        res1 += b + d;
                    }
                }
                now = t1;
                t1 += a;
                t2 += c;

            }
        }
        ll ans = res * len + res1;
        printf("%lld
", ans);
    }
}

int main()
{
#ifdef LOCAL_JUDGE
    freopen("Text.txt", "r", stdin);
#endif // LOCAL_JUDGE

    RUN();

#ifdef LOCAL_JUDGE
    fclose(stdin);
#endif // LOCAL_JUDGE
    return 0;
}

K XOR Clique

题意：给出n个数，求选出一个点集，使得里面的点两两异或不超过这两个数中小的那个，求点集里面元素个数最大是多少

思路：枚举最高位

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const ll MOD = (int)1e9 + 7;
const int maxn = (int)1e6 + 10;

int n, num;
int arr[40];

inline void RUN()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int ans = 0;
        scanf("%d", &n);
        memset(arr, 0, sizeof arr);
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d", &num);
            int cnt = 0;
            while (num)
            {
                cnt++;
                num >>= 1;
            }
            arr[cnt]++;
            ans = max(ans, arr[cnt]);
        }
        printf("%d
", ans);
    }
}

int main()
{
#ifdef LOCAL_JUDGE
    freopen("Text.txt", "r", stdin);
#endif // LOCAL_JUDGE

    RUN();

#ifdef LOCAL_JUDGE
    fclose(stdin);
#endif // LOCAL_JUDGE
    return 0;
}