[hihocoder][Offer收割]编程练习赛60

hohahola

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<functional>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef queue<int> QI;
 
void makedata() {
    freopen("input.txt", "w", stdout);
    fclose(stdout);
}
 
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    //makedata();
    std::ios::sync_with_stdio(), cin.tie();
    lint n, x, y, z;
    cin >> n >> x >> y >> z;
    if (z >= y) cout << (n * z / x) << endl;
    else {
        lint l = , r = n, mid;
        lint ans = ;
        while (l +  < r) {
            mid = (l + r) / ;
            if ((n - mid) * z >= (x - y) * mid) {
                l = mid;
                ans = max(ans, mid);
            } else r = mid;
        }
        cout << ans << endl;
    }
    return ;
}

最大顺子

要使顺子的值最大，m张任意牌肯定全用完了，因为任意牌可以放在有数字的牌的右边

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<functional>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef queue<int> QI;
 
void makedata() {
    freopen("input.txt", "w", stdout);
    fclose(stdout);
}
 
lint a[], f[], s[];
 
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    //makedata();
    std::ios::sync_with_stdio(), cin.tie();
    int n, m, k;
    cin >> n >> m >> k;
    for (int i = ; i < n; i++) cin >> a[i];
    sort(a, a + n);
    lint ans = ;
    int p = k - m;
    for (int i = ; i + p -  < n; i++) {
        int j = i + p - ;
        if (a[j] - a[i] +  - p <= m) ans = max(ans, a[i] + k - );
    }
    cout << ans << endl;
    return ;
}

路径包含问题

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<functional>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef queue<int> QI;
 
void makedata() {
    freopen("input.txt", "w", stdout);
    fclose(stdout);
}
 
class LCA {
public:
    int n;
    int ancient[][], depth[], father[], sz[];
    vector<vector<int>> * T;
    void init(vector<vector<int>> *, int, int);
    void dfs(int, int, int);
    int query(int, int);
};
void LCA::dfs(int root, int fa, int dep) {
    ancient[root][] = fa;
    depth[root] = dep;
    sz[root] = ;
    for (int i = ; i < (*T)[root].size(); i++) {
        int u = (*T)[root][i];
        if (u == fa) continue;
        dfs(u, root, dep + );
        sz[root] += sz[u];
    }
}
void LCA::init(vector<vector<int>> * G, int root, int nn) {
    T = G, n = nn;
    dfs(root, -, );
    for (int i = ; i < ; i++) ancient[root][i] = -;
    for (int i = ; i < ; i++) {
        for (int j = ; j <= n; j++) {
            if (ancient[j][i - ] == -) ancient[j][i] = -;
            else ancient[j][i] = ancient[ancient[j][i - ]][i - ];
        }
    }
}
int LCA::query(int u, int v) {
    if (depth[u] > depth[v]) swap(u, v);
    int d = ;
    while (depth[u] != depth[v]) {
        if ((depth[v] - depth[u]) & ( << d)) v = ancient[v][d];
        d++;
    }
    if (u == v) return u;
    for (int i = ; i >= ; i--) {
        if (ancient[u][i] != ancient[v][i]) u = ancient[u][i], v = ancient[v][i];
    }
    return ancient[u][];
}
 
LCA lca;
vector<vector<int>> G(, vector<int>());;
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    //makedata();
    std::ios::sync_with_stdio(), cin.tie();
    int n, m, u, v;
    cin >> n >> m;
    for (int i = ; i < n; i++) {
        cin >> u >> v;
        G[u].push_back(v);
    }
    lca.init(&G, , n);
    for (int i = ; i < m; i++) {
        cin >> u >> v;
        if (lca.depth[u] > lca.depth[v]) swap(u, v);
        int w = lca.query(u, v), vv = v;
        if (w == u) {
            int d = ;
            while (lca.depth[u] != lca.depth[vv] - ) {
                if ((lca.depth[vv] -  - lca.depth[u]) & ( << d)) vv = lca.ancient[vv][d];
                d++;
            }
            cout << (1LL * (n - lca.sz[vv])*lca.sz[v]) << endl;
        } else cout << (1LL * lca.sz[u] * lca.sz[v]) << endl;
    }
    return ;
}

树上的节点cd之间有两种关系，其中一个是另一个的祖先，或两者都不是对方的祖先，判断两者的关系，把路径两端的点的数量相乘

随机排列

枚举左边界

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<functional>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef queue<int> QI;
 
void makedata() {
    freopen("input.txt", "w", stdout);
    fclose(stdout);
}
 
lint ans[];
int a[], m[][], M[][], LOG2[];
 
void init(int n) {
    for (int i = ; i <= n; i++) LOG2[i] = LOG2[i >> ] + ;
    for (int i = ; i <= n; i++) m[i][] = M[i][] = a[i];
    for (int j = ; ( << j) <= n; j++) {
        for (int i = ; i + ( << j) -  <= n; i++) {
            m[i][j] = min(m[i][j - ], m[i + ( << (j - ))][j - ]);
            M[i][j] = max(M[i][j - ], M[i + ( << (j - ))][j - ]);
        }
    }
}
int query(int l, int r) {
    int k = LOG2[r - l + ];
    return max(M[l][k], M[r - ( << k) + ][k]) - min(m[l][k], m[r - ( << k) + ][k]);
}
 
VI R, C;
 
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    //makedata();
    std::ios::sync_with_stdio(), cin.tie();
    int n, t;
    cin >> t;
    while (t--) {
        cin >> n;
        for (int i = ; i <= n; i++) cin >> a[i];
        memset(ans, , sizeof(ans));
        init(n);
        R.clear();
        for (int i = n; i >= ; i--) {
            C = R;
            R.clear();
            R.push_back(i);
            for (int j = ; j < C.size(); j++) {
                if (query(i, R[R.size() - ]) != query(i, C[j])) R.push_back(C[j]);
            }
            for (int j = ; j < R.size() - ; j++) ans[query(i, R[j])] += R[j + ] - R[j];
            ans[query(i, R[R.size() - ])] += n - R[R.size() - ] + ;
        }
        for (int i = ; i < n; i++) {
            cout << ans[i] << endl;
            ans[i + ] += ans[i];
        }
    }
    return ;
}