2020-08-06 HDU多校第六场1001、1002、1006题解

目录

1001 Road To The 3rd Building、

1002 Little Rabbit's Equation、

1006 A Very Easy Graph Problem

---

1001 Road To The 3rd Building

题意就不说了。

思路：计算每个数对答案的贡献。对于，贡献为；对于，贡献为......将这些贡献的计算总结在表格中。先暂时不看乘号前的数字，乘号后的数规律为：。然后单独看乘号前的数，会发现这个N*N的表格，最外圈全为1，第二圈全为2，第三圈全为3，直到第N/2圈。因此计算答案时一圈一圈的算。在计算第  圈时，我的计算方法是先计算这一圈的第一列和最后一列的和，然后计算第一行和最后一行去掉首尾的和。

第一列和最后一列的计算公式为：

第一行与最后一行去掉首尾的计算公式为：

注意当N是奇数时，最后一圈N/2 + 1只有一个数，单独计算。

因此只需要计算出1~maxn的逆元、以及S数组的前缀和就可以根据上面俩公式算出总贡献。

这时的贡献时所有方案的贡献，因为要输出期望，而每种方案出现的概率时相同的，共有种方案，因此再乘就是答案。

 

样例三表格示例

1 * (S_1 / 1)	1 * S_1 / 2	1 * S_1 / 3	1 * S_1 / 4	1 * S_1 / 5
1 * (S_2 / 1)	2 * S_2 / 2	2 * S_2 / 3	2 * S_2 / 4	2 * S_2 / 5
1 * (S_3 / 1)	2 * S_3 / 2	3 * S_3 / 3	3 * S_3 / 4	3 * S_3 / 5
1 * (S_4) / 1	2 * S_4 / 2	3 * S_4 / 3	4 * S_4 / 4	4 * S_4 / 5
1 * (S_5 / 1)	2 * (S_5 / 2)	3 * (S_5) / 3	4 * (S_5 / 4)	5 * (S_5 / 5)
1 * (S_6 / 1)	2 * (S_6 / 2)	3 * (S_6 ) / 3	4 * (S_6 / 4)	4 * (S_6 / 5)
1 * (S_7 / 1)	2 * (S_7/ 2)	3 * (S_7 / 3)	3 * (S_7 / 4)	3 * (S_7/ 5)
1 * (S_8 / 1)	2 * (S_8 / 2)	2 * (S_8 / 3	2 * (S_8 / 4)	2 * (S_8 / 5)
1 * (S_9 / 1)	1 * (S_9 / 2)	1 * (S_9 / 3	1 * (S_9/ 4)	1 * (S_9 / 5)

AC代码：

/*---------------------------------
 *File name: A.cpp
 *Creation date: 2020-08-05 22:33
 *全华班
 *-------------------------------*/
#pragma GCC diagnostic error "-std=c++11"
#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define LL long long
#define PII pair<int, int> 
using namespace std;
const int maxn = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const LL mod = 1e9 + 7;

inline int read(){
    char c = getchar();
    while(!isdigit(c)) c = getchar();
    int x = 0;
    while(isdigit(c)){
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x;
}

inline LL fpow(LL x, LL y){
    x %= mod;
    LL ans = 1;
    while(y){
        if(y & 1) ans = ans * x % mod;
        x = x * x % mod;
        y >>= 1;
    }
    return ans;
}

LL s[maxn];
LL pre[maxn];
LL sum[maxn];

inline void init(){
    pre[1] = 1;
    for(int i = 2; i < maxn; ++i){
        pre[i] = pre[i - 1] + fpow(i * 1ll, mod - 2);
        pre[i] %= mod;
    }
}

int main(){
    init();
    int T = read();
    while(T--){
        LL n; scanf("%lld", &n);
        sum[0] = 0;
        for(int i = 1; i <= n; ++i) scanf("%lld", &s[i]), sum[i] = sum[i - 1] + s[i], sum[i] %= mod;
        int mid = n >> 1;
        LL ans = 0;
        for(LL i = 1; i <= mid; ++i){
            ans += (sum[n - i + 1] - sum[i - 1] + mod) % mod * i % mod * ((fpow((n - i + 1) * 1ll, mod - 2) + fpow(i * 1ll, mod - 2)) % mod) % mod;
            ans %= mod;
            ans += i * ((s[i] + s[n - i + 1]) % mod) % mod * ((pre[n - i] - pre[i] + mod) % mod) % mod;
            ans %= mod;
        }
        if(n & 1) {
            ++mid;
            ans += s[mid] * mid % mod * fpow(mid * 1LL, mod - 2) % mod;
            ans %= mod;
        }
        ans = ans * fpow(n * (n + 1) / 2, mod - 2);
        ans %= mod;
        printf("%lld\n", ans);
    }
    return 0;
}

1002 Little Rabbit's Equation

思路：很水的一个暴力题。只要将输入的表达式拆分成三个字符串，然后枚举所有进制，当小字符串在当前进制下合法（所有数位上的数小于进制），将其转化为十进制数，判断十进制下表达式是否成立。如果都不成立就输出-1。

AC代码：

/*---------------------------------
 *File name: A.cpp
 *Creation date: 2020-08-05 22:33
 *全华班
 *-------------------------------*/
#pragma GCC diagnostic error "-std=c++11"
#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define LL long long
#define PII pair<int, int> 
using namespace std;
const int maxn = 1e5 + 5;
const int inf = 0x3f3f3f3f;
const LL mod = 1e9 + 7;

inline int read(){
    char c = getchar();
    while(!isdigit(c)) c = getchar();
    int x = 0;
    while(isdigit(c)){
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x;
}

inline bool op(char x){
    if(x == '+') return 0;
    if(x == '-') return 0;
    if(x == '*') return 0;
    if(x == '/') return 0;
    if(x == '=') return 0;
    return 1;
}

char s[20];

inline void cal(int &cur, string &x){
    int len = strlen(s);
    while(cur < len && op(s[cur])){
        if(x.size() == 0) if(s[cur] == '0'){
            cur++;
            continue;
        }
        x += s[cur++];
    }
    cur++;
}

inline LL change(int cur, string x){
    int len = x.size();
    LL Base = 1;
    LL ans = 0;
    for(int i = len - 1; i >= 0; --i){
        int c;
        if(x[i] >= '0' && x[i] <= '9') c = x[i] - '0';
        else if(x[i] <= 'F' && x[i] >= 'A') c = x[i] - 'A' + 10;
        if(c >= cur) return -1;
        ans += c * Base;
        Base = Base * cur;
    }
    return ans;
}

inline bool judge(LL a, LL b, LL c, char op){
    if(op == '+') if(a + b == c) return 1;
    if(op == '-') if(a - b == c) return 1;
    if(op == '*') if(a * b == c) return 1;
    if(op == '/') if(c * b == a) return 1;
    return 0;
}

int main(){
    while(~scanf(" %s", s)){
        string x, y, z;
        int cur = 0;
        char op;
        cal(cur, x); op = s[cur - 1];
        cal(cur, y);
        cal(cur, z);
        int ans = -1;
        for(int i = 2; i <= 16; ++i){
            LL a, b, c;
            a = change(i, x); if(a == -1) continue;
            b = change(i, y); if(b == -1) continue;
            c = change(i, z); if(c == -1) continue;
            if(judge(a, b, c, op)){
                ans = i;
                break;
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

1006 A Very Easy Graph Problem

思路：因为边权是按照输入顺序递增的。且对于第  条边，前  条边的权值和都小于第  条边，因此按照输入顺序建新图，当输入边的两个端点不属于同一连通块时在新图中加入这条边，输入结束后的新图必定是一颗树，且两点间的距离必定在旧图中也是最小的。随意选取树上的一个点作为根节点，跑一遍DFS，记录下每个点以及它所有子树的权值为1的点的个数和以及权值0的点的个数和。因为题目的限制，因此对答案有贡献的边必定都在树上。又根据乘号后的表达式的要求，某一条边被遍历的次数必定是这条边下面的所有权值1的点的个数 * 这条边上面所有权值0的点的个数 + 下面所有权值0的点的个数 * 上面所有权值1的点的个数。因此只要直到一个点的所有子结点中有多少个权值flag结点，将总flag权值结点个数-子结点中flag权值结点个数就是上面的flag权值结点个数。具体的看代码吧。

AC代码：

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

#define fi first
#define se second
#define mp make_pair
#define LL long long
#define pii pair<int, int>

const LL mod = 1e9 + 7;
const int maxn = 2e5 + 5;
const LL inf = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);

vector<int> G[maxn];

LL w[maxn];
int a[maxn], u[maxn], v[maxn];

int pre[maxn], dfn[maxn];
bool add[maxn];

int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }

int cnt, sum[2], num[maxn][2];

void dfs(int now, int fa) {
    dfn[now] = ++cnt;
    int len = G[now].size();
    num[now][0] = (a[now] == 0);
    num[now][1] = (a[now] == 1);
    for(int i = 0; i < len; ++i) {
        int son = G[now][i];
        if(son == fa) continue;
        dfs(son, now);
        num[now][0] += num[son][0];
        num[now][1] += num[son][1];
    }
}

int main() {
    w[0] = 1LL;
    for(int i = 1; i < maxn; ++i) {
        w[i] = w[i - 1] * 2LL % mod;
    }
    int T; cin >> T;
    while(T--) {
        int n, m;
        scanf("%d%d", &n, &m);
        sum[0] = sum[1] = 0;
        for(int i = 1; i <= n; ++i) {
            scanf("%d", a + i);
            sum[0] += (a[i] == 0);
            sum[1] += (a[i] == 1);
            pre[i] = i; G[i].clear();
        }
        memset(add, false, sizeof add);
        for(int i = 1; i <= m; ++i) {
            scanf("%d%d", u + i, v + i);
            int fu = find(u[i]);
            int fv = find(v[i]);
            if(fu == fv) continue;
            pre[fv] = fu;
            add[i] = true;
            G[u[i]].push_back(v[i]);
            G[v[i]].push_back(u[i]);
        }
        cnt = 0; dfs(1, 0);
        LL ans = 0;
        for(int i = 1; i <= m; ++i) {
            if(!add[i]) continue;
            int fa = u[i], son = v[i];
            if(dfn[fa] > dfn[son]) swap(fa, son);
            int fa0 = sum[0] - num[son][0];
            int fa1 = sum[1] - num[son][1];
            ans = (ans + w[i] * (fa0 * num[son][1] % mod) % mod) % mod;
            ans = (ans + w[i] * (fa1 * num[son][0] % mod) % mod) % mod;
        }
        printf("%lld\n", ans);
    }
    return 0;
}