2025-11-17 ZYZ28-NOIP模拟赛-Round7 hetao1733837的record

2025-11-17 ZYZ28-NOIP模拟赛-Round7 hetao1733837的record

好累😩

比赛链接：ZYZ28-NOIP模拟赛-Round7 - ZYZOJ

A.pmst

$(‵▽\prime )\psi$$lz$竟然把原来的$T2$塞进了$T1$！是想坑谁？还好我盒到了原。

原题链接：Darnassus

提交链接：07-A - ZYZOJ

分析

思路还是比较简单的，最开始思考方向也是正确的，及由于是排列，差值的绝对值取在$1$到$n-1$，连接$(i,i+1)$的边，其边权一定小于$n$。从极限的角度考虑，$|p_i-p_j|\le \sqrt{n}$，$|i-j|\le \sqrt{n}$，那么，每个点$O(n)$建图，全局$O(n^2)$建图就可以降到$O(\sqrt{n})$，然后跑$Kruskal$复杂度就是$O(n\sqrt{n}logn)$。边权范围$[1,n]$，开桶记录，不必排序，最终复杂度$O(n\sqrt{n}\alpha (n))$。

正解

#include <bits/stdc++.h>
using namespace std;
const int N = 50005;
int n, p[N], fa[N], cnt[N];
vector<pair<int, int>> e[N];
int find(int x){
    return x == fa[x] ? fa[x] : fa[x] = find(fa[x]);
}
int main(){
    freopen("pmst.in", "r", stdin);
    freopen("pmst.out", "w", stdout);
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
	cin >> n;
    for (int i = 1; i <= n; i++){
        cin >> p[i];
        cnt[p[i]] = i;
        fa[i] = i;
    }
    int tmp = sqrt(n) + 1;
    for (int i = 1; i < n; i++){
        for (int j = i + 1; j <= min(n, i + tmp); j++){
            long long w = 1ll * (j - i) * abs(p[i] - p[j]);
            if (w <= n - 1)
                e[w].push_back({i, j});
        }
        for (int j = i + 1; j <= min(n, i + tmp); j++){
            long long w = 1ll * (j - i) * abs(cnt[i] - cnt[j]);
            if (w <= n - 1)
                e[w].push_back({cnt[i], cnt[j]});
        }
    }
    int cnt = 0;
    long long ans = 0;
    for (int w = 1; w < n && cnt != n - 1; w++){
        for (auto o : e[w]){
            int u = find(o.first);
            int v = find(o.second);
            if (u == v)
                continue;
            fa[u] = v;
            ans += w;
            ++cnt;
            if (cnt == n - 1)
                break;
        }
    }
    cout << ans;
}

注意，QOJ本题是多测，需修改读入。

B.cardgame

这题没盒到原/(ㄒoㄒ)/~~

提交链接：07-B - ZYZOJ

题面

小$Y$和小$Z$在卡牌游戏中对战。小$Y$有$N$张卡牌而小$Z$有$M$张卡牌。每张卡牌均有一个由正整数表示的力量值。

每一回合，小$Y$和小$Z$各自展示一张卡牌，如果一名玩家的卡牌力量值大于对手的卡牌力量值，则该玩家被视为胜出此回合。如果展示的两张卡牌具有相同的力量值，则此回合被视为和局。 小$Y$的第$i$张卡牌的力量值为$A_i$。小Z的第$j$张卡牌的力量值为$B_j$。 然后，他们将进行$N\times M$轮的对战。他们都循环地展示卡牌。

小$Y$依照以下顺序展示卡牌（共$M$轮）:$A_1\to A_2\to \cdots \to A_N\to A_1\to A_2\to \cdots \to A_N\to \cdots \to A_1\to A_2\to \cdots \to A_N$

小Z依照以下顺序展示卡牌（共$N$轮）：$B_1\to B_2\to \cdots \to B_M\to B_1\to B_2\to \cdots \to B_M\to \cdots \to B_1\to B_2\to \cdots \to B_M$

请你求出在这个过程中小$Y$获胜、小$Z$获胜及和局的回合数。

分析

显然思路又对了……为啥没过呢？心态浮躁？代码能力弱？思维还是不行？单纯运气不好？我不知道……但是，前段时间学习方法是绝对有问题的，一直在抄题解，没有自主思考，不热爱思考，必须纠正。

我们很容易想到，两者并不必须走$N\times M$轮，只需走$lcm(N,M)$轮即可，而且，相对应的位置，它们下标一定在模$gcd(N,M)$下同余。那么，对于每一种，排序，然后二分(实现上也可以用双指针)即可，时间复杂度$O((N+M)log(N+M))$。

正解

#include <bits/stdc++.h>
#define int long long
using namespace std;
int n, m;
signed main() {
	freopen("cardgame.in", "r", stdin);
	freopen("cardgame.out", "w", stdout);
	cin >> n >> m;
	vector<int> a(n), b(m);
	for (auto &o: a) 
		cin >> o;
	for (auto &o: b) 
		cin >> o;
	int Y = 0, Z = 0;
	int GCD = __gcd(n, m);
	for (int mod = 0; mod < GCD; mod++) {
		vector<int> A, B;
		for (int j = mod; j < n; j += GCD) 
            A.push_back(a[j]);
		for (int j = mod; j < m; j += GCD) 
            B.push_back(b[j]);
		sort(A.begin(), A.end());
		sort(B.begin(), B.end());
		int pntb = 0;
		for (auto x: A) {
			while (pntb < (int)B.size() && B[pntb] < x) 
				++pntb;
			Y += pntb;
		}
		int pnta = 0;
		for (auto x: B) {
			while (pnta < (int)A.size() && A[pnta] < x) 
				++pnta;
			Z += pnta;
		}
	}
	Y *= GCD;
	Z *= GCD;
	int delta = n * m - Y - Z;
	cout << Y << "\n" << Z << "\n" << delta << "\n";
}

操了，场上连二分都写出来了，看了一眼std，tmd连实现都是计算两个再用总数减……

C.jump

操，死机没保存上/ll

题面

比特国由$N$个城市构成，编号为$1,2,\dots ,N$。 有$M$条双向道路连接这些城市，第$i$条连通城市$U_i$和城市$V_i$，通过这条道路需要花费$W_i$ 的时间。 此外，比特国的人们还可以使用“比特跳跃”来通行于任意两个城市之间。比特跳跃所需的时间取决于两个常数$S$和$K$，两者均为整数。对于从城市$x$跳跃到城市$y$：

· $S=1$：传送需要$K\times (x\&y)$单位时间（$\&$表示按位与(bitwise AND)）。

· $S=2$：传送需要$K\times (x\oplus y)$单位时间（$\oplus$表示按位异或(bitwise XOR)）。

· $S=3$：传送需要$K\times (x|y)$单位时间（$|$表示按位或(bitwise OR)）。

请你计算从$1$号城市移动到每个城市所需的最短时间。

分析

$O(n^2)$建图显然是很不错的那份手段，但不妨多想一想。

对于$N$是$2$的整数次幂，从$1$跳到$N$，代价为$0$，从$N$跳到任意点，代价均为$0$，输出$N-1$个$0$即可。

S=1

扩展一下，找出最大的$t$使得$2^t-1\le N$，那么，这些点都价值为$0$，剩余只需求补码即可。

但是出现了一个特例，就是说$N=2^{t+1}-1$，那么补码为$0$，需要$O(n)$建边，跑最短路。

S=2

对于异或，如果要从$a$到达$b$，若两者之间某一位二进制位不同，则可以通过$a\oplus 2^{?}$解决。同理，所以，变成了$O(nlogn)$建边，再跑最短路即可，非常划算。

S=3

或运算是三种位运算中唯一单调递增的，所以，一次跳跃不劣于多次跳跃。除非从其子集而来。那么，从$1$使用$O(n)$建图，先跑一遍$Dijkstra$，再建好每个数二进制下的子集，再跑一遍最短路即可。

正解

STD写得比较扭曲，但是这种写法确实比较整齐但是也挺丑的。

#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
template<typename T>
bool chmin(T &x, T val){
    if (val < x){
        x = val;
        return true;
    }
    return false;
}
template<typename T>
bool chmax(T &x, T val){
    if (x < val){
        x = val;
        return true;
    }
    return false;
}
int n, m, s;
long long k; 
vector<pair<int, long long>> e[N];
long long d[N];
long long son[N];
int main(){
    freopen("jump.in", "r", stdin);
    freopen("jump.out", "w", stdout);
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m >> s >> k;
    for (int i = 1; i <= m; i++){
        int u, v;
        long long w;
        cin >> u >> v >> w;
        e[u].push_back({v, w});
        e[v].push_back({u, w});
    }
    memset(d, 0x3f, sizeof(d));
    auto dijkstra = [&](){
        priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<pair<long long, int>>> q;
        d[1] = 0;
        q.push({0, 1});
        while (!q.empty()){
            long long w = q.top().first;
            int u = q.top().second;
            q.pop();
            if (d[u] != w)
                continue;
            for (auto tmp : e[u]){
                int v = tmp.first;
                long long weight = tmp.second;
                if (chmin(d[v], w + weight))
                    q.push({d[v], v});
            }
        }
    };
    if (s == 1){
        int x = n;
        ++x;
        while (x % 2 == 0)
            x /= 2;
        if (x == 1){
            for (int i = 2; i < n; i++){
                e[1].push_back({i, 0});
                e[i].push_back({1, 0});
            }
            for (int i = 1; i < n; i++){
                e[i].push_back({n, k * (i & n)});
                e[n].push_back({i, k * (i & n)});
            }
            dijkstra();
            for (int i = 2; i <= n; i++)
                cout << d[i] << " ";
        }
        else{
            for (int i = 2; i <= n; i++)
                cout << 0 << " ";
        }
        return 0;
    }
    if (s == 2){
        int lg = 1;
        while ((1 << lg) <= n)
            ++lg;
        for (int i = 1; i <= n; i++){
            for (int j = 0; j < lg; j++){
                if ((1 << j) & i){
                    int x = i ^ (1 << j);
                    if (x >= 0 && x <= n){
                        e[i].push_back({x, k * (1 << j)});
                        e[x].push_back({i, k * (1 << j)});
                    }
                }
            }
        }
        dijkstra();
        for (int i = 2; i <= n; i++)
            cout << d[i] << " ";
        return 0;
    }
    if (s == 3){
        for (int i = 2; i <= n; i++){
            e[1].push_back({i, k * (1 | i)});
            e[i].push_back({1, k * (1 | i)});
        }
        dijkstra();
        for (int i = 1; i <= n; i++){
            son[i] = d[i];
            for (int j = 1; j < i; j <<= 1)
                if (i & j)
                    chmin(son[i], son[i ^ j]);
            chmin(d[i], son[i] + k * i);
        }
        priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<pair<long long, int>>> q;
        for (int i = 1; i <= n; i++)
            q.push({d[i], i});
        while (!q.empty()){
            long long w = q.top().first;
            int u = q.top().second;
            q.pop();
            if (d[u] != w)
                continue;
            for (auto tmp : e[u]){
                int v = tmp.first;
                long long weight = tmp.second;
                if (chmin(d[v], w + weight))
                    q.push({d[v], v});
            }
        }
        for (int i = 2; i <= n; i++)
            cout << d[i] << " ";
    }
}

D.interval

提交链接：07-D - ZYZOJ

题面

给定一个长度为$N$的数列$A_1,A_2,\dots ,A_N$和一个长度为$N-1$的数列$B_2,B_3,\dots ,B_N$。 有$Q$个询问，每次询问给出一个区间$[L_i,R_i]$。请你求出有多少二元组$(l,r)$满足：

· $L_i\le l<r\le R_i$

· ∀ i ∈ { l + 1 , l + 2 , … , r − 1 } , A l > A i \forall i \in \{l+1, l+2, \dots, r-1\}, A_l > A_i ∀i∈{l+1,l+2,…,r−1},Al​>Ai​ （如果$l+1==r$则忽略这一条件，认为符合）

· $ \forall i \in {l, l+1, \dots, r-1}, B_r > A_i $

分析

$N\le 400,Q\le 400$

预处理区间最大值，暴力枚举答案，$O(1)$判断。总复杂度$O(N^{2}Q)$。

$N\le 3000,Q\le 300$

枚举左端点$l$，找到第一个不小于$A_l$的位置$A_x$，那么$r$最大取到$x$。

查询$r\in [l+1,x]$内$B_r>A_l$的点的个数即可。

可以预处理从每个$l$开始的答案，查询$O(1)$。

总复杂度$O(QNlogN)$或$O(QN)$（预处理每个点不小于自己最近的位置——二分或单调栈）。

$A_i,B_i\le 3$

$l+1=r$的情况预处理，前缀和+差分直接$O(1)$统计。

否则，长度不小于3，唯一的情况就是$A_l=2,B_r=3$，区间里所有其他的$A_i=1$。

因此对于每个$r$，可能的$l$最多只有1个。

把所有答案放在平面上，扫描线+二维数点。

复杂度$O((N+Q)logn)$。

$2\le N,Q\le 3\times 10^5,1\le L,R\le N,1\le A_i\le 10^9,1\le B_i\le 10^9$

把询问离线到右端点，枚举右端点，统一回答此处的询问。

对于每个$r$，找到最小的$L[r]$使得$\forall i\in [L[r],r-1]$都有$A_i\le B_r$。

可以使用$ST$表+二分。那么对于$r$可能的l就在$[L[r],r-1]$中。

线段树维护，对于此时的最大右端点限制，区间里的可行起点个数。

考虑令$r$为答案数对中的右端点，那么对于每个“当前向右看依然没找到跟自己一样高或者更高”的$A_l$，都可以产生一个贡献。单调栈维护当前这类$A_l$，在线段树维护区间内允许的起点数，每次相当于区间让对应的这些位置答案$+1$。

总复杂度$O((N+Q)logN)$。

正解

#include <bits/stdc++.h>
using namespace std;
#define fir first
#define sec second
#define mp make_pair
#define pb push_back
typedef long long int64;
typedef pair<int, int> PII;
const int Max_N = 300005;
int64 Ans[Max_N];
vector<PII> qry[Max_N];
int N, Q, A[Max_N], B[Max_N], L[Max_N];
namespace Sparse_table {
	int st[20][Max_N], lg[Max_N];

	void init() {
		lg[0] = -1;
		for (int i = 1; i <= N; i++)
			lg[i] = lg[i >> 1] + 1;
		for (int i = 1; i <= N; i++)
			st[0][i] = A[i];
		for (int i = 1; (1 << i) <= N; i++)
			for (int j = 1; j + (1 << i) - 1 <= N; j++)
				st[i][j] = max(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
	}

	int query(int l, int r) {
		int k = lg[r - l + 1];
		return max(st[k][l], st[k][r - (1 << k) + 1]);
	}
}
namespace Segment_tree {
	#define lc (root << 1)
	#define rc ((root << 1) | 1)
	int cnt[Max_N << 2], tag[Max_N << 2];
	int64 sum[Max_N << 2];
	void pushdown(int root) {
		sum[lc] += 1LL * tag[root] * cnt[lc];
		sum[rc] += 1LL * tag[root] * cnt[rc];
		tag[lc] += tag[root], tag[rc] += tag[root];
		tag[root] = 0;
	}
	void modify(int root, int tl, int tr, int p, int d) {
		if (tl == tr) {cnt[root] += d; return;}
		pushdown(root);
		int mid((tl + tr) >> 1);
		if (p <= mid) modify(lc, tl, mid, p, d);
		else modify(rc, mid + 1, tr, p, d);
		cnt[root] += d;
	}
	void update(int root, int tl, int tr, int ql, int qr) {
		if (ql <= tl && tr <= qr) {
			tag[root]++;
			sum[root] += cnt[root];
			return;
		}
		pushdown(root);
		int mid((tl + tr) >> 1);
		if (ql <= mid)
			update(lc, tl, mid, ql, qr);
		if (qr > mid)
			update(rc, mid + 1, tr, ql, qr);
		sum[root] = sum[lc] + sum[rc];
	}
	int64 query(int root, int tl, int tr, int ql, int qr) {
		if (ql <= tl && tr <= qr) return sum[root];
		pushdown(root);
		int64 ret(0);
		int mid((tl + tr) >> 1);
		if (ql <= mid)
			ret += query(lc, tl, mid, ql, qr);
		if (qr > mid)
			ret += query(rc, mid + 1, tr, ql, qr);
		return ret;
	}
}
namespace Solve {
	void init() {
		scanf("%d", &N);
		for (int i = 1; i <= N; i++)
			scanf("%d", &A[i]);
		for (int i = 2; i <= N; i++)
			scanf("%d", &B[i]);
		scanf("%d", &Q);
		for (int l, r, i = 1; i <= Q; i++) {
			scanf("%d%d", &l, &r);
			assert(l < r);
			qry[r].pb(mp(l, i));
		}
		Sparse_table::init();
		for (int i = 2; i <= N; i++) {
			int l = 1, r = i - 1, m, ret = i;
			while (l <= r) {
				m = (l + r) >> 1;
				if (Sparse_table::query(m, i - 1) < B[i])
					ret = m, r = m - 1;
				else
					l = m + 1;
			}
			L[i] = ret;
		}
	}
	void work() {
		static int stk[Max_N], top = 0;
		for (int i = 1; i < N; i++) {
			while (top > 0 && A[ stk[top] ] <= A[i])
				Segment_tree::modify(1, 1, N, stk[top--], -1);
			Segment_tree::modify(1, 1, N, stk[++top] = i, 1);
			if (L[i + 1] != i + 1)
				Segment_tree::update(1, 1, N, L[i + 1], i);
			for (size_t j = 0; j < qry[i + 1].size(); j++)
				Ans[ qry[i + 1][j].sec ] = Segment_tree::query(1, 1, N, qry[i + 1][j].fir, i);
		}
		for (int i = 1; i <= Q; i++)
			printf("%lld\n", Ans[i]);
	}
	void __main__() {
		init();
		work();
	}
}
int main() {	
	freopen("interval.in", "r", stdin);
	freopen("interval.out", "w", stdout);
	Solve::__main__();
	return 0;
}