怀化学院第十五届大学生计算机程序设计竞赛题解

已于 2023-09-14 22:30:09 修改
阅读量293 收藏 3
点赞数
文章标签： 算法 c++
于 2023-09-14 22:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62242287/article/details/132813133
版权

A-Fibonacci   

        递推式和矩阵乘法

        斐波那契数列有递推公式


        我们可以把这个计算过程抽象成一个矩阵运算的过程。

        那么对于第 n 项，我们有：


快速幂

        对于一个指数为正整数的幂运算，我们有：


        依次递推，我们可以把幂运算的复杂度，从 O(n)降低到 O(\log_2n)。
        而我们又知道矩阵乘法运算是符合结合律的，所以可以使用快速幂。

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

#define int long long
#define PII pair<int,int>
#define x first
#define y second
#define endl '\n'

const int N=1e6+10,M=2*N,p=1e9+7,INF=0x3f3f3f3f;

int qmul(int a, int b)
{
	int res = 0;
	while (b)
	{
		if (b & 1) res = (res + a) % p;
		a = (a + a) % p;
		b >>= 1;
	}
	return res;
}

void mul(int c[][2], int a[][2], int b[][2])  // c = a * b
{
	static int t[2][2];
	memset(t, 0, sizeof t);
	
	for (int i = 0; i < 2; i ++ )
		for (int j = 0; j < 2; j ++ )
			for (int k = 0; k < 2; k ++ )
				t[i][j] = (t[i][j] + qmul(a[i][k], b[k][j])) % p;
	
	memcpy(c, t, sizeof t);
}

int F(int n)
{
	if (!n) return 0;
	
	int f[2][2] = {1, 1};
	int a[2][2] = {
		{0, 1},
		{1, 1},
	};
	
	for (int k = n - 1; k; k >>= 1)
	{
		if (k & 1) mul(f, f, a);  // f = f * a
		mul(a, a, a);  // a = a * a
	}
	
	return f[0][0];
}


void solve()
{
	int n;
	cin>>n;
	cout<<F(n)<<endl;
	
	return;
}

signed main()
{
//	ios::sync_with_stdio(0);
//	cin.tie(0),cout.tie(0);
	
	int T=1;
	cin>>T;
	while(T--)
		solve();
	
	return 0;
}

B-传送

        设 元形式幂级数 G(x_1,x_2,...,x_n)。

                                G(x_1,x_2,..,x_n)=\sum_{i_1,i_2,...,i_k}c_{i_1,i_2,...,i_k}x_{1}^{i_1}x_{1}^{i_1}***x_{n}^{i_n}
其中 c_{i_1,i_2,...,i_k} 表示向量 (i_1,i_2,...,i_k) 作为技能出现的次数。
        我们希望求出 F(x_1,x_2,...,x_n) 表示：

                                F(x_1,x_2,...,x_n)=\sum_{i=0}^{\infty }G(x_1,x_2,...,x_n)^i=\frac{1}{1-G(x_1,x_2,...,x_n)}
那么其中 F(x_1,x_2,...,x_n) 的系数 d_{i_1,i_2,...,i_k} 则表示利用技能集合凑出向量 (i_1,i_2,...,i_k) 的方案数。
        对于存在障碍物的方案数求解我们只需要 O(m^2) 的容斥即可，设 f_i 表示到达第 个点的方案数。

                                f_i=ways(p_i)-\sum_{j,p_i \leq p_j }f_j
这里 p_i 表示第 i 个关键点的坐标向量，ways(p_i) 表示组合出向量 p_i 的方案数，定义 k 维向量的 p_i 小于 p_i 为每一维均小于，同时 p_i-p_j 为每一维相减。
        现在我们只需要解决一个问题就是 k 元形式幂级数的求逆。
        首先解决 k 元多项式乘法，对于常见的 k 比较小的情况可以将每一维的值域扩张成两倍，然后直接做卷积并舍弃进位的情况即可。
        对于 k 较大的情况，我们多引入一维 t , 并引入占位函数 \chi (i)=\left \lfloor \frac{i}{n_1} \right \rfloor + \left \lfloor \frac{i}{n_1n_2} \right \rfloor+...+\left \lfloor \frac{i}{n_1n_2...n_{k-1}} \right \rfloor ，将函数表示成 \sum _{i}f_ix^it^{\chi (i)} 。
        多引入一个元可以增强对卷积的限制，我们原先的问题在于我们将向量重标号后，进行加法之后的标号会产生进位并对答案产生影响，在引入 之后还需要满足 \chi (i)+\chi (j)=\chi (x+j) ，注意到有 \left \lfloor \frac{i}{x} \right \rfloor+\left \lfloor \frac{j}{x} \right \rfloor-\left \lfloor \frac{i+j}{x} \right \rfloor\in \{-1,0\}，所以 \{\chi (i-j)+\chi(j)\} 合法的集合很小。于是我们只需要计算 \sum _{i}f_ix^it^{\chi (i)} 在 mod(t^k-1) 意义下的多项式乘法，也就是循环卷积。
        由于 k\leq \log_2N ，那么就可以对每一维度做长度为 2N 的 DFT，然后对于 t 暴力做卷积。对于求逆，只需像一元多项式一样利用牛顿迭代求解即可。求导也是一致的。
        时间复杂度为 O(kN\log N)

#include <bits/stdc++.h>
 
using namespace std;
using i64 = long long;
 
template<int MOD>
struct ModInt {
    int x;
 
    ModInt() : x(0) {}
    ModInt(i64 y) : x(y >= 0 ? y % MOD : (MOD - (-y) % MOD) % MOD) {}
 
    inline int inc(const int &x) {
        return x >= MOD ? x - MOD : x;
    }
    inline int dec(const int &x) {
        return x < 0 ? x + MOD : x;
    }
 
    ModInt &operator+= (const ModInt &p) {
        x = inc(x + p.x);
        return *this;
    } 
    ModInt &operator-= (const ModInt &p) {
        x = dec(x - p.x);
        return *this;
    }
 
    ModInt &operator*= (const ModInt &p) {
        x = (int)(1ll * x * p.x % MOD);
        return *this;
    }
    ModInt &operator/= (const ModInt &p) {
        *this *= p.inverse();
        return *this;
    }
 
    ModInt operator-() const { return ModInt(-x); } 
 
    friend ModInt operator + (const ModInt& lhs, const ModInt& rhs) {
        return ModInt(lhs) += rhs;
    }
    friend ModInt operator - (const ModInt& lhs, const ModInt& rhs) {
        return ModInt(lhs) -= rhs;
    }
    friend ModInt operator * (const ModInt& lhs, const ModInt& rhs) {
        return ModInt(lhs) *= rhs;
    }
    friend ModInt operator / (const ModInt& lhs, const ModInt& rhs) {
        return ModInt(lhs) /= rhs;
    }
 
    bool operator == (const ModInt &p) const { return x == p.x; } 
    bool operator != (const ModInt &p) const { return x != p.x; }
 
    ModInt inverse() const {
        int a = x, b = MOD, u = 1, v = 0, t;
        while(b > 0) {
            t = a / b;
            swap(a -= t * b, b);
            swap(u -= t * v, v);
        }
        return ModInt(u);
    }
 
    ModInt pow(i64 n) const {
        ModInt ret(1), mul(x);
        while(n > 0) {
            if(n & 1) ret *= mul;
            mul *= mul;
            n >>= 1;
        }
        return ret;
    }
 
    friend ostream &operator<<(ostream &os, const ModInt &p) {
        return os << p.x;
    }
 
    friend istream &operator>>(istream &is, ModInt &a) {
        i64 t;
        is >> t;
        a = ModInt<MOD>(t);
        return (is);
    }
    static int get_mod() { return MOD; }
};
 
const int MOD = 998244353;
using MInt = ModInt<MOD>;
 
inline int add(int x, int y) {
    return x + y >= MOD ? x + y - MOD : x + y;
}
 
inline void addx(int &x, int y) {
    x = add(x , y);
}
 
inline int sub(int x, int y) {
    return x - y < 0 ? x - y + MOD : x - y;
}
 
inline void subx(int &x, int y) {
    x = sub(x , y);
}
 
inline int mul(int x, int y) { return 1ull * x * y % MOD; }
 
inline int fpow(int x, int y) {
    int ans = 1;
    while (y) {
        if (y & 1) ans = mul(ans, x);
        y >>= 1; x = mul(x, x);
    }
    return ans;
}
 
vector <int> roots, rev;
 
void getRevRoot(int base) {
    int n = 1 << base;
    if ((int)roots.size() == n) return;
    roots.resize(n); rev.resize(n);
    for (int i = 1; i < n; i++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (base - 1));
    for (int mid = 1; mid < n; mid <<= 1) {
        int wn = fpow(3, (MOD - 1) / (mid << 1));
        roots[mid] = 1;
        for (int i = 1; i < mid; i++) roots[i + mid] = mul(roots[i + mid - 1], wn);
    }
}
 
void ntt(vector <int> &a, int base) {
    int n = 1 << base;
    for (int i = 0; i < n; i++) {
        if (i < rev[i]) {
            swap(a[i], a[rev[i]]);
        }
    }
    for (int mid = 1; mid < n; mid <<= 1) {
        for (int i = 0; i < n; i += (mid << 1)) {
            for (int j = 0; j < mid; j++) {
                int x = a[i + j], y = mul(a[i + j + mid], roots[mid + j]);
                a[i + j] = add(x, y); a[i + j + mid] = sub(x, y);
            }
        }
    }
}
 
const i64 P = 1ll * MOD * MOD;
const int N = 1001 * 1001 + 5, M = 22, U = 1005;
 
vector <int> F[M], G[M], tmp, ANS;
int n[M], facn[M], nt[N];
map<vector<int> , int> suf , ways;
int lim, k, dis;
 
vector<int> da;
void dfs1(int u) {
    if (u == k + 1) {
        int id = 0;
        for (int i = 1; i <= k; i++) id += da[i] * facn[i - 1];
            // cout << id << endl;
        int flag = 1;
        for (int i = 1 ; i <= k ; i++) {
            flag &= da[i] == 0;
        }
        if (flag == 1) tmp[id] = 1;
        else {
            if (suf.count(da)) tmp[id] = MOD - suf[da];
        }
        return;
    }
    for (int i = 0; i < n[u]; i++) {
        da[u] = i;
        dfs1(u + 1);
    }
}
 
void dfs2(int u) {
    if (u == k + 1) {
        int id = 0;
        for (int i = 1; i <= k; i++) id += da[i] * facn[i - 1];
        ways[da] = ANS[id];
        return;
    }
    for (int i = 0; i < n[u]; i++) {
        da[u] = i;
        dfs2(u + 1);
    }
}
 
vector <int> mul(vector <int> a, vector <int> b, int need, int ntted = 0, int limit = 0) {
    int len = (int)a.size() + (int)b.size() - 1, base = 0;
    if (limit) len = limit;
    while ((1 << base) < len) ++base;
    getRevRoot(base);
    for (int i = 0; i < k; i++) {
        F[i].clear(); F[i].resize(1 << base);
        if (!ntted) {
            G[i].clear(); G[i].resize(1 << base);
        }
    }
    for (int i = 0; i < (int)a.size(); i++) F[nt[i]][i] = a[i];
    if (!ntted) {
        for (int i = 0; i < (int)b.size(); i++) G[nt[i]][i] = b[i];
    }
    for (int i = 0; i < k; i++) {
        ntt(F[i], base);
        if (!ntted) ntt(G[i], base);
    }
    for (int i = 0; i < (1 << base); i++) {
        static i64 res[M];
        memset(res, 0, sizeof(res));
        for (int j = 0; j < k; j++) {
            for (int t = 0; t < k; t++) {
                int go = (j + t >= k ? j + t - k : j + t); 
                res[go] += 1ll * F[j][i] * G[t][i];
                if (res[go] >= P) res[go] -= P;
            }
        }
        for (int j = 0; j < k; j++) F[j][i] = res[j] % MOD;
    }
    int inv = fpow(1 << base, MOD - 2);
    for (int i = 0; i < k; i++) {
        ntt(F[i], base);
        reverse(F[i].begin() + 1, F[i].end());
    }
    vector <int> ans(need);
    for (int i = 0; i < need; i++) ans[i] = mul(inv, F[nt[i]][i]);
    return ans;
}
 
vector <int> pinv(vector <int> a, int n) {
    a.resize(n);
    if (n == 1) {
        vector <int> ans(1, fpow(a[0], MOD - 2));
        return ans;
    }
    vector <int> f0 = pinv(a, (n + 1) >> 1);
    vector <int> tmp = mul(a, f0, n, 0, n), ans = f0;
    for (int i = 0; i < (int)f0.size(); i++) tmp[i] = 0;
    tmp = mul(tmp, f0, n, 1, n); ans.resize(n);
    for (int i = (int)f0.size(); i < n; i++) ans[i] = sub(0, tmp[i]);
    return ans;
}
 
int main() {
    cin.tie(nullptr)->sync_with_stdio(0);
    int T;
    cin >> T;
 
    while (T--)
    {
        cin >> k;
        for (int i = 1 ; i <= k ; i++) {
            cin >> n[i];
            n[i]++;
        }
        int _ , __;
        cin >> _ >> __;
        suf.clear() , ways.clear();
        while(_--){
            vector<int> d(k + 1);
            for (int i = 1 ; i <= k ; i++) {
                cin >> d[i];
            }
            suf[d]++;
        }
        facn[0] = 1;
        for (int i = 1; i <= k; i++) facn[i] = facn[i - 1] * n[i];
        lim = facn[k];
        tmp.clear() , tmp.resize(lim);
        da.clear() , da.resize(k + 1);
        dfs1(1);
        for (int i = 0; i < lim; i++) {
            int res = 0;
            for (int j = 1; j < k; j++) res += i / facn[j];
            nt[i] = res % k;
        }
        ANS = pinv(tmp, lim);
        dfs2(1);
        vector<MInt> f(__ + 1);
        vector<vector<int>> v(__ + 1);
 
 
        v[0] = vector<int>(k + 1);
 
        for (int i = 1 ; i <= k ; i++) {
            v[0][i] = ::n[i] - 1;
        }
        for(int i = 1 ; i <= __ ; i++) {
            v[i] = vector<int>(k + 1);
            for (int j = 1 ; j <= k ; j++) {
                cin >> v[i][j];
            }
        }
 
        sort(v.begin() , v.end());
 
        auto check = [&](vector<int> a , vector<int> b) {
            int flag = 1;
            for (int i = 1 ; i <= k ; i++) {
                flag &= a[i] <= b[i];
            }
            return flag;
        };
 
        auto sub = [&](vector<int> a , vector<int> b) {
            auto ret = a;
            for (int i = 1 ; i <= k ; i++) {
                ret[i] -= b[i];
            }
            return ret;
        };
 
        for(int i = 0 ; i <= __ ; i++){
            f[i] = ways[v[i]];
            for(int j = 0 ; j < i ; j++) {
                if(check(v[j] , v[i])) {
                    f[i] -= f[j] * ways[sub(v[i] , v[j])];
                }
            }
        }
        cout << f[__] << '\n';
    }
}

C-生成树问题

        令第 i 种权值的边有 c_i 条。首先考虑二分答案，二分答案后则对于每种权值 i，限制
不能取超过 x_i 条边。不妨将问题转化为，限制每种权值的边不能删去超过 {x_i}'=c_i-x_i 条边，并且要求删去选出来的边之后全图联通。不难发现，存在一棵生成树满足条件(权值 i 出现次数不超过 x_i )，等价于在新的限制下，能删去的边的总数等于 \sum {x_i}'。另一方面，删除边集小于等于 x_i 和删边后联通均为拟阵，即可使用拟阵交解决问题。复杂度O(n^3\log(w))。

#include<bits/stdc++.h>
using namespace std;
const int N = 505;
int n , m;
map<int,vector<pair<int,int>>>E;
map<int,int> cnt , limit;
typedef long long ll;
struct uni {
    int p[N];
    int cnt ;
    void init() {
        for(int i = 1;i <= n;i++) p[i] = i;
        cnt = n;
    }
    int Find(int x)
    {
        return p[x] == x ? x : p[x] = Find(p[x]) ;
    }
    bool Merge(int u,int v)
    {
        u = Find(u) , v = Find(v);
        if(u == v) return 0;
        p[u] = v; cnt--;
        return 1;
    }
    bool in(int u,int v)
    {
        return Find(u) == Find(v);
    }
}Un[N];
struct edge {
    int u , v , w;
};
bool mat[N][N];
int dis[N] , from[N] , mark[N];
bool tar[N];
queue<int> q;
vector<edge> I , rI;
bool bfs()
{
    for(int i = 1;i <= m;i++) mark[i] = 0 , from[i] = -1;
    int t = -1;
    while(q.size() && t == -1) {
        int u = q.front() ; q.pop();
        if(tar[u]) {t = u ; break ;}
        for(int i = 1;i <= m;i++) {
            if(mat[u][i] && dis[i] > dis[u] + 1) {
                dis[i] = dis[u] + 1; from[i] = u;
                if(tar[i]) {t = i ; break ;}
                q.push(i);
            }
        }
    }
    while(q.size()) q.pop();
    if(t == -1) {return 0;}
    while(t != -1) {
        mark[t] = 1 ; t = from[t];
    }
    vector<edge> new_I , new_rI;
    for(int i = 0;i < I.size();i++) {
        if(mark[i + 1]) new_rI.push_back(I[i]);
        else new_I.push_back(I[i]);
    }
    for(int i = 0;i < rI.size();i++) {
        if(mark[i + 1 + I.size()]) new_I.push_back(rI[i]);
        else new_rI.push_back(rI[i]);
    }
    swap(I , new_I) ; swap(rI , new_rI);
    return 1;
}
bool chk(ll lm)
{
    int sum = 0;
     I.clear() ; rI.clear();
    for(auto &[w , v] : E) {
        limit[w] = max(0LL , (ll)v.size() - lm / w) ;
        sum += limit[w];
    }
    Un[0].init();
    map<int,vector<int> > take;
    cnt.clear();
    for(auto &[w , v] : E) {
        int a,b;
        take[w].resize(v.size()); cnt[w] = v.size();
        for(int i = 0;i < v.size();i++) {
            a = v[i].first , b = v[i].second;
            if(!Un[0].in(a , b)) {
                Un[0].Merge(a , b);
                take[w][i] = 1;
                cnt[w]--;
            }
        }
    }
    for(auto &[w , v] : E) {
        int a , b;
        for(int i = 0;i < v.size() && cnt[w] > limit[w];i++) {
            if(take[w][i]) continue;
            a = v[i].first , b = v[i].second ;
            take[w][i] = 1 ; cnt[w]--;
        }
    }
    for(auto &[w , v] : E) {
        int a , b;
        for(int i = 0;i < v.size() ;i++) {
            a = v[i].first , b = v[i].second ;
            if(take[w][i]) {
                rI.push_back((edge){a , b , w});
            }
            else {I.push_back((edge){a , b , w}); }
        }
    }
    ///F1 : connect
    ///F2 : num limit
    int cc = 0;
    do{
     /*   printf("Round I : \n");
        for(auto S : I) {
            printf("%d %d %d\n",S.u,S.v,S.w);
        }
        printf("Round rI : \n");
        for(auto S : rI) {
            printf("%d %d %d\n",S.u,S.v,S.w);
        }*/
        cnt.clear() ;cc++;
        for(auto &S : I) cnt[S.w]++;
        for(int j = 1;j <= rI.size();j++) {
            Un[j].init() ;
            for(int i = 0;i < rI.size();i++) {
                if(i != j - 1) Un[j].Merge(rI[i].u , rI[i].v);
            }
        }
        for(int i = 1;i <= m;i++) for(int j = 1;j <= m;j++) mat[i][j] = 0;
        int tlm[505];
        for(int j = 0;j < rI.size();j++) tlm[j] = limit[rI[j].w];
        for(int i = 1;i <= I.size();i++) {
            for(int j = 1;j <= rI.size();j++) {
                ///i -> j , I\{i} + {j} in F1
                if(Un[j].cnt == 1 || (Un[j].cnt == 2 && !Un[j].in(I[i - 1].u , I[i - 1].v))) {mat[i][j + I.size()] = 1;}
                ///j -> i , I\{i} + {j} in F2
                if(I[i - 1].w == rI[j - 1].w) mat[j + I.size()][i] = 1;
                else if(cnt[rI[j - 1].w] < tlm[j - 1]) {mat[j + I.size()][i] = 1;}
            }
        }
        //for(int i = 1;i <= m;i++ , printf("\n")) for(int j = 1;j <= m;j++) printf("%d ",mat[i][j]);
        for(int i = 1;i <= m;i++) tar[i] = 0 , dis[i] = 1e9;
        for(int j = 1;j <= rI.size();j++) {
            if(Un[j].cnt == 1) {dis[j + I.size()] = 0 , q.push(j + I.size()); /*printf("IN_F1 %d\n",j);*/}
            if(cnt[rI[j - 1].w] < tlm[j - 1]) {tar[j + I.size()] = 1; /*printf("IN_F2 %d\n",j);*/}
        }
    }while(bfs());
    if(I.size() == sum) return 1;
    return 0;
}
ll set_min(ll x)
{
    ll sol = 0;
    for(auto &[w,v] : E) {
        sol = max(sol , x/w * w);
    }
    return sol;
}
ll set_max(ll x)
{
    ll sol = 1e18;
    for(auto &[w , v] : E) {
        sol = min(sol , (x/w + 1) * w - 1);
    }
    return sol;
}
void solve()
{
    cin >> n >> m;
    E.clear(); cnt.clear() ; limit.clear();
    ll r = 0;
    for(int i = 1;i <= m;i++) {
        int u , v , w;cin >> u >> v >> w;
        E[w].push_back(pair<int,int>{u , v});
        r = max(r , (ll)(1LL*w*E[w].size()));
    }
    ll l = 1;
    while(l < r) {
        ll md = (l + r >> 1);
        if(chk(md)) {r = md; r = max(l,set_min(r));}
        else {l = min(r , set_max(md) + 1);}
        //cout <<l<<' ' << r <<' ' <<r - l <<'\n';
    }
    cout << l << '\n';
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out2.txt","w",stdout);
    ios::sync_with_stdio(false) ; cin.tie(0) ; cout.tie(0);
    int t;cin >> t;
    while(t--) solve();
}

D-城市建造者

        

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

const int _ = 1e5 + 5;
const int __ = 2e5 + 5;

int n, m;

int p[_];
bool vis[__];
int u[__], v[__];

int dsu(int x) {
  return p[x] == x ? x : p[x] = dsu(p[x]);
}

int main() {
  #ifdef Sakuyalove
    freopen("in.in", "r", stdin);
    freopen("out.out", "w", stdout);
  #endif
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int T;
  cin >> T;
  while (T--) {
    memset(vis, 0, sizeof vis);
    memset(p, 0, sizeof p);
    memset(u, 0, sizeof u);
    memset(v, 0, sizeof v);
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
      p[i] = i;
    }
    for (int i = 1; i <= m; i++) {
      cin >> u[i] >> v[i];
    }
    int tot = m;
    for (int i = m; i >= 1; i--) {
      int x = dsu(u[i]), y = dsu(v[i]);
      if (x != y) {
        tot--;
        vis[i] = 1;
        p[x] = y;
      }
    }
    cout << tot << endl;
    for (int i = 1; i <= m; i++) {
      if (!vis[i]) cout << i << ' ';
    }
    cout << endl;
  }
  return 0;
}

E-A#B（签到题）

        很明显题目是要求 x^n，但是出题人很狗，把暴力做法卡掉了，所以套个快速幂板子就能过啦。


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

#define int long long
#define PII pair<int,int>
#define x first
#define y second
#define endl '\n'

const int mod=1e9+7;

int qmi(int a,int b)
{
    int res=1;
    while(b)
    {
        if(b&1)
            res=res*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return res;
}

signed main() {
    int n,a,b;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a>>b;
        cout<<"Case #"<<i<<" : "<<qmi(a,b)<<endl;
    }
}
// 64 位输出请用 printf("%lld")

F-阿华的面试题

        乍一看这道题像是最短路问题，但是仔细分析会发现直接用最短路算法会超时，该死的出题人。画个比较复杂的样例之后，你会惊奇的发现这题居然是LCA，于是我们只需要套用板子就行了，可以参考AcWing_1171。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
using namespace std;

#define PII pair<int,int>
const int N=100010,M=N*2;

int h[N],w[M],e[M],ne[M],idx;
int dist[N],p[N],res[N];
int st[N],n,m;
vector<PII> query[N];

void add(int a,int b,int c)
{
	e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int find(int x)
{
	if(x==p[x])return x;
	return p[x]=find(p[x]);
}

void dfs(int u,int fa)
{
	for(int i=h[u];~i;i=ne[i])
	{
		int j=e[i];
		if(j==fa)continue;
		dist[j]=dist[u]+w[i];
		dfs(j,u);
	}
}

void tarjan(int u)
{
	st[u]=1;
	for(int i=h[u];~i;i=ne[i])
	{
		int j=e[i];
		if(!st[j])
		{
			tarjan(j);
			p[j]=u;
		}
	}
	
	for(auto item:query[u])
	{
		int y=item.first,id=item.second;
		if(st[y]==2)
		{
			int anc=find(y);
			res[id]=dist[u]+dist[y]-2*dist[anc];
		}
	}
	st[u]=2;
}

int main()
{
	memset(h,-1,sizeof h);
	scanf("%d",&n);
	for(int i=0;i<n-1;i++)
	{
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c),add(b,a,c);
	}
	
	scanf("%d",&m);
	for(int i=0;i<m;i++)
	{
		int a,b;
		scanf("%d%d",&a,&b);
		if(a!=b)
		{
			query[a].push_back({b,i});
			query[b].push_back({a,i});
		}
	}
	
	for(int i=0;i<=n;i++)
		p[i]=i;
	
	dfs(1,-1);
	tarjan(1);
	
	for(int i=0;i<m;i++)
		printf("%d\n",res[i]);
}

G-爱玩游戏的阿华

        观察发现加体力的道具收益和休息是一样的，加属性的道具收益不如训练，增加训练效果的道具收益和训练一样。
        得到有体力就训练，没体力就休息的决策，于是回合数为偶数时属性值直接(n/2)*15。
        考虑回合数为奇数的情况，训练休息轮流的策略会导致一个回合没有收益，考虑通过比赛和道具来获得这一个回合的收益。
        首先需要通过一个加 50 的体力药或者两个加的小体力药来获得比赛消耗的体力。相当于消耗一个回合但不消耗体力，获得 50金币，将多余的一个回合转化为了商店币。
        然后考虑通过商店币能获得的属性， 50 商店币能转化为一次加 6 的属性书或者两次加 3 的小属性书。
        所以 n 为奇数时被分为：浪费一个回合，属性多加 3，属性多加 6，属性多加 7，一共四种情况，分别计算出对应的概率即可。

#include <bits/stdc++.h>

using namespace std;

const int mod=1e9+7;

int T,n,P;

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

int main(){
	// freopen("data1.in","r",stdin);
	// freopen("data1.out","w",stdout);
    ios::sync_with_stdio(false);
    cin>>T;
    while(T--){
        cin>>n>>P;
        if(!n){
            cout<<"0\n";
            continue;
        }
        if(n<6){
            cout<<(n/2+1)*15<<'\n';
            continue;
        }
        if(n&1){
            int t=n/6;
            int P1=(1-qpow(1-P+mod,t)+mod)%mod;//一种道具一个以��?
            int P2=(1-(qpow(1-P+mod,t)+1ll*qpow(1-P+mod,t-1)*P%mod*t%mod)%mod+mod)%mod;//一种道具两个以��?
            int PP=(1-1ll*(1-P1+mod)*(1-P2+mod)%mod+mod)%mod;//有体力药
            int p1=1ll*PP*P1%mod;
            int p2=1ll*PP*qpow(1-P+mod,t)%mod*P2%mod;
            int p3=1ll*PP*qpow(1-P+mod,t)%mod*(1ll*qpow(1-P+mod,t-1)*P%mod*t%mod)%mod;
            int p4=(1-((p1+p2)%mod+p3)%mod+mod)%mod;
            cout<<(((15ll*(n/2)%mod+22)*p1%mod
                   +(15ll*(n/2)%mod+21)*p2%mod)%mod
                  +((15ll*(n/2)%mod+18)*p3%mod
                   +(15ll*(n/2)%mod+15)*p4%mod)%mod)%mod<<'\n';
        }else{
            cout<<(15ll*(n/2)%mod+15)%mod<<'\n';
        }
    }
    return 0;
}

H-循环同构

        求出字符串的最小表示法，然后两个串如果循环同构那么两个字符串相等。利用hash判断即可。利用后缀自动机或者后缀数组之类的做法也可以通过本题。

#include<bits/stdc++.h>
using namespace std;
const int Mod = 666623333;
int T, n, m, Q, a[100005];
char s[200005];
int main(){
	scanf("%d", &T);
	while (T--){
		scanf("%d%d", &n, &m);
		for (int i = 1; i <= n; i++){
			scanf("%s", s + 1);
			for (int j = m + 1; j <= m + m; j++)
				s[j] = s[j - m];
			int I = 1, J = 2;
			while (J <= m){
				ok:;
				for (int k = 0; k < m; k++){
					if (s[I + k] < s[J + k]){
						J += k;
						break;
					}
					if (s[I + k] > s[J + k]){
						int tmp = I;
						I = J;
						J = max(J, tmp + k);
						break;	
					}
				}
				J++;
			}
			a[i] = 0;
			for (int j = 0; j < m; j++)
				a[i] = (31ll * a[i] + s[I + j] - 'a' + 1) % Mod;
		}
		scanf("%d", &Q);
		while (Q--){
			int x, y;
			scanf("%d%d", &x, &y);
			if (a[x] == a[y])
				puts("Yes");
			else
				puts("No");
		}
	}
	return 0;
}

I-Coin

        考虑建立最大流模型：
        源点 S 向每个人连 1 的流量。按时间顺序拆点，每个人拆成 M 个点，M 个点之间连 a_i 的流量，对每次操作给定的 (A,B)，在对应时间点上连双向的的流量（正向边流量为1，反向边流量也为1），对于 K 个朋友点，它们的最后一个时间的点向 T 连 a_{b_i} 流量的边。这样建图，点数和边数都为 O(N*M)，现在考虑对上面的最大流进行优化。可以发现，拆出来的很多点是用不上的。所以没必要每个点都拆成 M 个点。每个人只要把选中自己的那个时间点拓展出来就行。换句话说，刚开始每个人没有点，对于每个操作，只要把选中的那两个人多扩展出一个点即可。这样建图后点数为 O(M), 边数为 O(M+K)。

        时间复杂度不超过 O(N*M)。

#include <bits/stdc++.h>
#define N 30000
#define S (N*2+1)
#define T (N*2+2)
#define INF 0x7FFFFFFF
#define rep(i, l, r) for (int i = (l); i <= (r); ++(i))
#define cmax(a,b) a=max(a,b)
#define cmin(a,b) a=min(a,b)
using namespace std;

inline int read() {
	int x = 0, f = 1; char ch = getchar();
	while (ch < '0' || ch > '9') {if (ch == '-')f = -1; ch = getchar();}
	while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
	return x * f;
}

struct edge {int nex, t, w;} e[500010];
int h[N*2 + 10], tot, d[N*2 + 10], q[N*2 + 10], qn, c[N*2 + 10];
int a[N + 5], p[N + 5], pn;
inline void Link(int x, int y, int w, int W = 0) {
	e[++tot] = (edge) {h[x], y, w}; h[x] = tot;
	e[++tot] = (edge) {h[y], x, W}; h[y] = tot;
}
bool bfs() {
	memset(d, 0, sizeof(d)); int i, j;
	for (d[q[i = qn = 0] = S] = 1; i <= qn; ++i)for (j = c[q[i]] = h[q[i]]; j; j = e[j].nex)
			if (e[j].w && !d[e[j].t])d[q[++qn] = e[j].t] = d[q[i]] + 1;
	return d[T];
}
int dfs(int x, int r) {
	if (x == T)return r;
	int k, u = 0;
	for (int&i = c[x]; i; i = e[i].nex)if (e[i].w && d[e[i].t] == d[x] + 1) {
			k = dfs(e[i].t, r - u < e[i].w ? r - u : e[i].w);
			u += k; e[i].w -= k; e[i ^ 1].w += k;
			if (u == r)return u;
		}
	return d[x] = 0, u;
}

void solve(){
	int n = read(), m = read(), k = read();
	rep(i,1,n)a[i] = read();
	memset(p, pn = 0, sizeof(p));
	memset(h, 0, sizeof(h)); tot = 1;
	rep(i,1,m) {
		int x = read(), y = read();
		p[x] ? Link(p[x], ++pn, a[x]) : Link(S, ++pn, 1); p[x] = pn;
		p[y] ? Link(p[y], ++pn, a[y]) : Link(S, ++pn, 1); p[y] = pn;
		Link(p[x], p[y], 1, 1);
	}
	for (int i = 1; i <= k; ++i) {
		int x = read();
		if (!p[x])Link(S, T, 1);
		else Link(p[x], T, a[x]);
	}
	int x;
	for (x = 0; bfs();)x += dfs(S, INF);
	printf("%d\n", x);
}

int main() {
	int t = read();
	while(t--)solve();
}

J-Huahua's internship

        根据题目的要求。我们先画一颗树来实验一下。

        

        因为题目要求染色的点的数量最多，所以我们考虑全部染成同一个颜色。但是，题目要求红色和蓝色都要出现，所以便有了下一张图。

        

        但这样打了绿色圆圈的边的两边就是不一样的颜色了，因此，我们必须不给 4 号点染色，即：

        其余情况可以自己推一下。

        不难发现，我们只能将一个结点不染色，然后将其删去，其余的连通块内部染成同一种颜色。我们可以枚举这个节点，然后 0-1 背包即可。

  #include<bits/stdc++.h>
  using namespace std;
  int n,cnt,tot,h[5005],w[5005],c[5005];
  bitset<5005>ans,dp;//0-1背包
  struct edge{
      int v,nxt;
  }e[10005];
  void adde(int u,int v){
      e[++cnt].nxt=h[u];
      h[u]=cnt;
      e[cnt].v=v;
  }//链式前向星
  void dfs(int x,int fa){
      w[x]++;
      for(int i=h[x];i;i=e[i].nxt){
          if(e[i].v==fa)continue;
          dfs(e[i].v,x);
          w[x]+=w[e[i].v];
      }
  }//求以1为根时分别以每个点为根的子树的节点数
  void dfs1(int x,int fa){
      int tot=0,sum=0;
      for(int i=h[x];i;i=e[i].nxt){
          if(e[i].v==fa)continue;
          c[++tot]=w[e[i].v];
          sum+=w[e[i].v];
      }
      c[++tot]=n-sum-1;
      dp.reset();
      dp[0]=1;
      for(int i=1;i<=tot;i++){
          for(int j=n;j>=c[i];j--){
              if(dp[j-c[i]])dp[j]=1;
          }
      }
      ans|=dp;//0-1背包
      for(int i=h[x];i;i=e[i].nxt){
          if(e[i].v==fa)continue;
          dfs1(e[i].v,x);
      }
  }
  int main()
  {
      scanf("%d",&n);
      for(int i=2,a,b;i<=n;i++)scanf("%d%d",&a,&b),adde(a,b),adde(b,a);
      dfs(1,0);
      dfs1(1,0);
      tot=0;
      for(int i=1;i<n-1;i++)if(ans[i])tot++;//一共有多少解
      printf("%d\n",tot);
      for(int i=1;i<n-1;i++)if(ans[i])printf("%d %d\n",i,n-i-1);//输出
      return 0;
  }

K-阿华的断言（签到题）

        鸽巢原理的应用，至少有一个堆中有 \left \lfloor \frac{m-1}{n} \right \rfloor+1 个元素。
        判断 d 和 \left \lfloor \frac{m-1}{n} \right \rfloor+1 的大小关系即可。

#include <bits/stdc++.h>
 
using namespace std;
 
 
int main() {
	cin.tie(nullptr)->sync_with_stdio(0);
 
	int T;
	cin >> T;
 
	while (T--) {
		int n , m , x;
		cin >> n >> m >> x;
 
		int d = (m - 1) / n + 1;
		if (x <= d) {
			cout << "Yes\n";
		} else {
			cout << "No\n";
		}
	}
	return 0;
}

Double.Qing
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
第十八届西南科技大学ACM程序设计竞赛题解
05-14
"西南科技大学第十八届ACM程序设计竞赛题解" 在本篇文章中，我们将对西南科技大学第十八届ACM程序设计竞赛的题解进行详细的分析和总结。 A. 花非花 题解： 本题的解题思路是先构造出一个序列，然后用动态规划算法...
2023年绍兴文理学院第十七届大学生程序设计竞赛-题解&std.rar
03-19
《2023年绍兴文理学院第十七届大学生程序设计竞赛题解解析》 在计算机科学领域，程序设计竞赛是提升编程技能、锻炼逻辑思维的重要途径。2023年绍兴文理学院第十七届大学生程序设计竞赛，无疑为参赛者提供了一个展示...
2024年第七届广西大学生程序设计大赛（正式赛）题解
weixin_45940369的博客
05-23 1444
2024年第七届广西大学生程序设计大赛（热身赛）题解
2024年第七届广西大学生程序设计大赛（热身赛）题解
weixin_45940369的博客
05-21 1029
2024年第七届广西大学生程序设计大赛（热身赛）题解
2022年湖南工学院第九届大学生计算机程序设计竞赛题解
qq_51034140的博客
09-18 525
s
第十五届吉林省大学生程序设计竞赛个人题解
Joler_的博客
04-26 2029
A. Random Number Checker 奇数和偶数的数量之差小于1即为Good B. Arithmetic Exercise 计算保留k位小数的a/b的结果 模拟除法即可，注意进位的细节 void solve() { ll a, b , k; cin >> a >> b >> k; vector <int> ve(1, a/b); ll c = a % b; for (int i..
2023年第13届山东省大学生程序设计竞赛题解
Texcavator的博客
04-27 2832
所以我们只需要枚举相同的前缀和长度：i 从 v 开始，每次找到最末尾的一个0并将其替换为1（即加上lowbit），假设路径按位与之后的前缀和长这样，我们需要判断有没有这样的路径可以满足条件。很容易发现，先进行一次操作1再进行一次操作2之后，前面进行过的操作1会被抵消，所以操作1永远不会在操作2前面进行，因此操作顺序是：先进行完所有的操作2，再进行所有的操作1。怎么消去呢，左边的可以利用以左上角为顶点和以右下角为顶点的方式消去，上边的可以利用以左上角为顶点和以右上角为顶点的方式消去。
题解 | 第二十届西南科技大学ACM大学生程序设计竞赛题解
每天多一点干货
06-08 755
计算机专业数据方向，目前有两个offer，不清楚哪个好想拜托大家帮忙选下一个是老家省会运营商，转正到。华为的测评挂了，然后hr说主管面暂时约不了得等测评重新申请，然后昨天又跟我说推给别的部门了，流程继续。有没有参加百度地图春招的朋友，目前在等排序，想问一下三面挂人概率大吗，一般多久出结果呢 #秋招# #三本造价女，之前在造价咨询公司实习过三个月，但是现在不想继续在工程行业干下去了，想去其他非本专业的。24届双非硕，Offer决赛圈。选择一：重庆集诚汽车电子，地点位于重庆南岸区茶园，汽车配件供应商，属。
2019湖南省计算机程序竞赛,2019第十五届“强智杯”湖南省大学生计算机程序设计竞赛 | 部分题解...
weixin_29962351的博客
07-16 536
叉姐出的题题解链接：https://github.com/ftiasch/problem-setting-public/tree/master/2019-hunanA.全1子矩阵签到题题目大意：给出一个01矩阵 判断所有的1是否充满了一个完整的矩阵思路：遍历一遍矩阵的所有数据，得到含1的位置矩阵的最小值，最大值(即该矩阵的左下角和右上角长*宽 = 1的数量#include using names...
第六届CCPC河南大学生程序设计竞赛部分题解
2302_81590667的博客
05-17 244
思路：首先可以判断每个数位上的数是否有偶数，如果有就可以把偶数放在最后一位上，这样就可以满足题意了，但如果数位上有零的话就把零最后输出，如果全是奇数，就输出97531.思路：这个题其实就是一个二分模板，可以吧绝对值去掉然后得到两个不等式，再根据两个不等式二分K，就行了，但在比赛时可能是紧张了没有想到就没有写出来。思路：可以先定义一个哈希数组把每一轮买地雷探测器需要的扫雷币存起来，再对每一轮买地雷探测器需要的扫雷币的数组排序，然后模拟就行了。思路：这个题是签到题根据题意模拟就行了。
一至七届 GXCPC广西大学生程序设计竞赛 题目与题解
weixin_45940369的博客
06-26 675
一至六届 GXCPC广西大学生程序设计竞赛 题目与题解
国际大学生程序设计竞赛例题解（一）.zip
11-08
程序设计竞赛相关代码、设计文档、使用说明，供学习参考 程序设计竞赛相关代码、设计文档、使用说明，供学习参考 程序设计竞赛相关代码、设计文档、使用说明，供学习参考 程序设计竞赛相关代码、设计文档、使用说明...
“中国东信杯”广西大学第四届程序设计竞赛（同步赛）题解
06-11
在“中国东信杯”广西大学第四届程序设计竞赛（同步赛）中，参赛者们面临着一系列挑战性的编程问题。这些问题涵盖了多个计算机科学和技术领域，包括算法设计、数据结构、数值计算以及数学应用。以下是其中一些题目的...
第45届ICPC国际大学生程序设计竞赛亚洲区域赛（沈阳站）题目题解
04-06
本资源为第45届ICPC国际大学生程序设计竞赛亚洲区域赛（沈阳站）题目题解，比赛时长一共五小时，题目为全英文题目，并且在比赛的时候可以使用一切纸质书籍，但禁止使用电子产品，一组三个队员，只允许使用一台电脑，...
算法日记day 45（单调栈之每日温度|接雨水）
最新发布
m0_74980681的博客
08-22 817
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 340
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 423
哈希表解决存在重复元素二问题
智能微气候:精准调控背后的算法革命
u010079117的博客
08-20 951
通过迁移学习,优化后的策略可快速移植到新的设施环境、新的作物品种,实现农业专家知识的规模化复用。农业知识图谱是智慧农业的基础设施。未来,LLM与5G、IoT等新一代信息技术的融合,将进一步提升设施农业的智能化水平,实现更精准、更高效、更环保的设施种植模式。另一方面,LLM可以学习农业专家的经验知识,通过知识蒸馏等技术,将专家经验转化为可解释、可迁移的计算机程序,助力农业生产智能化。温室、养殖舍等设施通过对光、温、水、气、肥等环境要素的调控,为作物和畜禽营造最适宜的生长环境,实现农业生产的高产、优质、高效。
最小区间00
青釉Oo的博客
08-21 454
最小区间
2024四川大学生程序设计竞赛题解
07-18
很抱歉，由于我是基于文本的模型，并不具备实时获取最新竞赛题解的能力。2024年的四川大学生程序设计竞赛的具体题目和官方题解通常会在比赛结束后由主办方公布，或者参赛者可以在官方网站、论坛、博客等地方找到分享的内容。 如果你想了解往届的竞赛题解，通常会涉及算法、数据结构、数学建模、系统设计等问题，解决这类题目需要扎实的编程基础，良好的逻辑思维，以及对常见问题的有效解决策略。如果你遇到某个具体的问题，可以描述一下，我会尽力提供一般性的分析和建议。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Double.Qing

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值