YACS2022年9月乙组

T1：区间交集（二）

这种统计有多少对满足题意，首先想下暴力
$O(n^2)$ 复杂度

正解：

判断区间是否有交集，其实比较麻烦，怎么简单判断？

如果已知左端点的大小顺序，那么判断是否有交集会很简单
由此可以得到一个思路，即对所有区间按照左端点从小到大排序，那么我们对于第 $i$ 个区间考虑第 $i+1 \sim n$ 个区间，这些区间的左端点都比第 $i$ 个区间的左端点大，那么只需判断右端点 $y$ 和这些左端点的关系（二分）

代码实现

 #include <bits/extc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
using ll = long long;
 
struct Interval {
    int l, r;
    Interval() {}
    Interval(int l, int r): l(l), r(r) {}
    bool operator<(const Interval& o) const {
        return l < o.l;
    }
};
 
inline int read() {
    int x = 0;
    char c;
    while (c < '0' or c > '9') c = getchar();
    while ('0' <= c and c <= '9') {
        x = x*10+c-'0';
        c = getchar();
    }
    return x;
}
 
int main() {
    int n = read();
    
    vector<Interval> intervals(n);
    rep(i, n) {
        intervals[i].l = read();
        intervals[i].r = read();
    }
    
    sort(intervals.begin(), intervals.end());
    
    ll ans = 0;
    rep(i, n) {
        // 每次找出有多少个 j>i 满足第 j 个区间和第 i 个区间相交 （intervals[j].l <= intervals[i].r）
        int ac = i, wa = n;
        while (abs(ac-wa) > 1) {
            int wj = (ac+wa)/2;
            if (intervals[wj].l <= intervals[i].r) ac = wj; else wa = wj;
        }
        ans += ac-i;
    }
    
    cout << ans << '\n';
    
    return 0;
}

T2：树的直径

模板题，求树的直径是一个很经典的问题
它需要一些数学结论

暴力：我们可以用一次 bfs 或者 dfs 求出所有点和 $v$ 的距离 $O(n)$
$n$ 次搜索，就能找出所有点两两之间的距离
$O(n^2)$ 会超时

需要使用数学结论：任选一个点 $v$ ，找到离 $v$ 最远的一个点 $u$ ，再找到离 $u$ 最远的点 $w$ ，则 $(u, w)$ 是一条直径

有了这个结论之后怎么做？
所以两次搜索可以解决本题，但是注意如果所有的点是一路悬挂下来的，则对于 dfs，它的栈空间开销量是很大的，冗余发生运行时错误（栈溢出）
最好使用 bfs （全局变量队列）

代码实现

 #include <bits/extc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
using P = pair<int, int>;
 
int main() {
    int n;
    cin >> n;
    
    vector<vector<int>> to(n);
    rep(i, n-1) {
        int a, b;
        cin >> a >> b;
        to[a].push_back(b);
        to[b].push_back(a);
    }
    
    queue<P> q;
    vector<bool> used(n);
    int last = 0, dist = 0;
    auto bfs = [&](int s) {
        rep(i, n) used[i] = false;
        used[s] = true;
        q.emplace(s, 0);
        while (q.size()) {
            auto [v, d] = q.front(); q.pop();
            last = v; 
            dist = d;
            for (int u : to[v]) {
                if (used[u]) continue;
                used[u] = true;
                q.emplace(u, d+1);
#####             }
        }
    };
    bfs(0);
    bfs(last);
    
    cout << dist << '\n';
    
    return 0;
}

最朴素的想法：搜索 search(int i) 表示前 $n-i$ 行已经定下来了
mp[i][j] 来表示某一个格子里面是否有棋子，col[i] 表示第 $i$ 列已经用了多少个棋子
重点其实不在于哪一列用了多少个棋子，而是有多少列用了 $0$ 个棋子，多少列用了 $1$ 个棋子，多少列用了 $2$ 个棋子
search(i, x, y, z)： $i$ 表示在填第 $i$ 行，前 $n-i$ 行已经填好了， $x$ 表示有多少列用了 $0$ 个棋子， $y$ 表示有多少列用了 $1$ 个棋子， $z$ 表示有多少列用了 $2$ 个棋子

稍微进行一些优化：其实可以不搜索，本质上是一个递推的过程
记 dp[i][x][y][z] 表示前 $n-i$ 行都已经按题意填好，其中有 $x$ 列用了 $0$ 个棋子， $y$ 列用了 $1$ 个棋子， $z$ 列用了 $2$ 个棋子，此时剩下的 $i$ 行有多少种填法
最后的答案就是 dp[n][m][0][0]

如何转移？
其实就是一个分类讨论的问题：

第 $i$ 行用了 $0$ 个棋子：
$dp[i-1][x][y][z]$
第 $i$ 行用了 $1$ 个棋子：
占用 $1$ 个只有 $0$ 个棋子的列： $dp[i-1][x-1][y+1][z]$
占用 $1$ 个只有 $1$ 个棋子的列： $dp[i-1][x][y-1][z+1]$
第 $i$ 行用了 $2$ 个棋子：
占用 $2$ 个有 $0$ 个棋子的列: $dp[i-1][x-2][y+2][z]$
占用 $2$ 个有 $1$ 个棋子的列： $dp[i-1][x][y-2][z+2]$
占用 $1$ 个有 $0$ 个棋子的列和 $1$ 个有 $1$ 个棋子的列： $dp[i-1][x-1][y][z+1]$

代码实现

 #include <bits/extc++.h>
#define rep(i, s, t) for (int i = (s); i <= (t); ++i)
 
using namespace std;
using ll = long long;
 
//const int mod = 998244353;
const int mod = 1000000007;
struct mint {
    ll x;
    mint(ll x=0):x((x%mod+mod)%mod) {}
    mint operator-() const {
        return mint(-x);
    }
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        return mint(*this) += a;
    }
    mint operator-(const mint a) const {
        return mint(*this) -= a;
    }
    mint operator*(const mint a) const {
        return mint(*this) *= a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
 
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint a) {
        return *this *= a.inv();
    }
    mint operator/(const mint a) const {
        return mint(*this) /= a;
    }
};
istream& operator>>(istream& is, mint& a) {
    return is >> a.x;
}
ostream& operator<<(ostream& os, const mint& a) {
    return os << a.x;
}
 
mint dp[2][101][101][101];
 
int main() {
    int n, m;
    cin >> n >> m;
    
    // 先初始化 dp[0]
    rep(x, 0, m)rep(y, 0, m) {
        if (x+y > m) break;
        int z = m-x-y;
        dp[0][x][y][z] = 1;
    }
    
    rep(i, 1, n) {
        rep(x, 0, m)rep(y, 0, m) {
            if (x+y > m) break;
            int z = m-x-y;
            if (y+2*z > 2*(n-i)) continue;
            
            mint now;
            // 1) 第 i 行用了 0 个棋子
            now = dp[i-1&1][x][y][z];
            // 2) 第 i 行用了 1 个棋子
            if (x) now += mint(x)*dp[i-1&1][x-1][y+1][z];
            if (y) now += mint(y)*dp[i-1&1][x][y-1][z+1];
            // 3) 第 i 行用了 2 个棋子
            if (x > 1) now += mint(x)*(x-1)/2 * dp[i-1&1][x-2][y+2][z];
            if (y > 1) now += mint(y)*(y-1)/2 * dp[i-1&1][x][y-2][z+2];
            if (x) now += mint(x)*y * dp[i-1&1][x-1][y][z+1];
            dp[i&1][x][y][z] = now;
        }
    }
    
    cout << dp[n&1][m][0][0] << '\n';
    
    return 0;
}

T4：购买商品

最暴力的做法：
枚举这 $k$ 张卡的支付顺序，对于每一个顺序，模拟购买过程，复杂度是 $O(n*k!)$

优化1：预处理出商品价格的前缀和 sum，二分去寻找新添加一张卡后可以一路买到第几个商品

优化2：
状压dp思想：
我们用一个 $k$ 位的二进制数来表示卡的使用情况
第 $i$ 位为 1 表示使用第 $i$ 张卡
则我们用 dp[state] 表示使用掉 $state$ 中代表的若干张卡后可购买完的最大商品数量

dp[state] 怎么求呢？
其实可以枚举 $state$ 中 1 的位置
假设这个位置代表的卡是最后一个使用的卡

 dp[state] = max(dp[state], sum 中不超过 sum[dp[state ^ 1<<i]]+v[i] 的最大商品数量)

代码实现

 #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
using ll = long long;
 
template<typename T>
inline void chmax(T& x, T y) { if (x < y) x = y; }
 
int main() {
    int n;
    cin >> n;
    vector<int> p(n);
    rep(i, n) cin >> p[i];
    vector<int> sum(n+1);
    rep(i, n) sum[i+1] = sum[i]+p[i];
    
    int k;
    cin >> k;
    vector<int> v(k);
    rep(i, k) cin >> v[i];
    
    int k2 = 1<<k;
    vector<int> dp(k2);
    rep(s, k2) {
        rep(i, k) { // 枚举 k 张卡
            if (s>>i&1) { // 表示 state 中有这张卡，则考虑把这张卡作为最后一个使用的卡
                int x = dp[s^(1<<i)]; // 不使用第 i 张卡，最多买下前 x 件商品
                int now = upper_bound(sum.begin()+1, sum.end(), sum[x]+v[i]) - sum.begin()-1;
                chmax(dp[s], now);
            }
        }
    }
    
    ll ans = 0;
    bool ok = false;
    rep(s, k2) {
        if (dp[s] != n) continue;
        ok = true;
        ll money = 0;
        rep(i, k) if (~s>>i&1) money += v[i];
        chmax(ans, money);
    }
    
    if (ok) cout << ans << '\n';
    else puts("Balance is insufficient");
    
    return 0;
}

posted on 2022-10-11 00:19 V_Melville 阅读(37) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· YACS2022年6月乙组

· YACS2022年9月丙组

· YACS-2023.11-金组

· 【总结】JOISC2022

· YACS-2022.6-银组

阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 使用C#创建一个MCP客户端
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现

导航

统计

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

YACS2022年9月乙组

T1：区间交集（二）

T2：树的直径

T3：棋盘问题

T4：购买商品

	#include <bits/extc++.h>
	#define rep(i, n) for (int i = 0; i < (n); ++i)

	using namespace std;
	using ll = long long;

	struct Interval {
	int l, r;
	Interval() {}
	Interval(int l, int r): l(l), r(r) {}
	bool operator<(const Interval& o) const {
	return l < o.l;
	}
	};

	inline int read() {
	int x = 0;
	char c;
	while (c < '0' or c > '9') c = getchar();
	while ('0' <= c and c <= '9') {
	x = x*10+c-'0';
	c = getchar();
	}
	return x;
	}

	int main() {
	int n = read();

	vector<Interval> intervals(n);
	rep(i, n) {
	intervals[i].l = read();
	intervals[i].r = read();
	}

	sort(intervals.begin(), intervals.end());

	ll ans = 0;
	rep(i, n) {
	// 每次找出有多少个 j>i 满足第 j 个区间和第 i 个区间相交（intervals[j].l <= intervals[i].r）
	int ac = i, wa = n;
	while (abs(ac-wa) > 1) {
	int wj = (ac+wa)/2;
	if (intervals[wj].l <= intervals[i].r) ac = wj; else wa = wj;
	}
	ans += ac-i;
	}

	cout << ans << '\n';

	return 0;
	}

	#include <bits/extc++.h>
	#define rep(i, s, t) for (int i = (s); i <= (t); ++i)

	using namespace std;
	using ll = long long;

	//const int mod = 998244353;
	const int mod = 1000000007;
	struct mint {
	ll x;
	mint(ll x=0):x((x%mod+mod)%mod) {}
	mint operator-() const {
	return mint(-x);
	}
	mint& operator+=(const mint a) {
	if ((x += a.x) >= mod) x -= mod;
	return *this;
	}
	mint& operator-=(const mint a) {
	if ((x += mod-a.x) >= mod) x -= mod;
	return *this;
	}
	mint& operator*=(const mint a) {
	(x *= a.x) %= mod;
	return *this;
	}
	mint operator+(const mint a) const {
	return mint(*this) += a;
	}
	mint operator-(const mint a) const {
	return mint(*this) -= a;
	}
	mint operator*(const mint a) const {
	return mint(this) = a;
	}
	mint pow(ll t) const {
	if (!t) return 1;
	mint a = pow(t>>1);
	a *= a;
	if (t&1) a = this;
	return a;
	}

	// for prime mod
	mint inv() const {
	return pow(mod-2);
	}
	mint& operator/=(const mint a) {
	return this = a.inv();
	}
	mint operator/(const mint a) const {
	return mint(*this) /= a;
	}
	};
	istream& operator>>(istream& is, mint& a) {
	return is >> a.x;
	}
	ostream& operator<<(ostream& os, const mint& a) {
	return os << a.x;
	}

	mint dp[2][101][101][101];

	int main() {
	int n, m;
	cin >> n >> m;

	// 先初始化 dp[0]
	rep(x, 0, m)rep(y, 0, m) {
	if (x+y > m) break;
	int z = m-x-y;
	dp[0][x][y][z] = 1;
	}

	rep(i, 1, n) {
	rep(x, 0, m)rep(y, 0, m) {
	if (x+y > m) break;
	int z = m-x-y;
	if (y+2z > 2(n-i)) continue;

	mint now;
	// 1) 第 i 行用了 0 个棋子
	now = dp[i-1&1][x][y][z];
	// 2) 第 i 行用了 1 个棋子
	if (x) now += mint(x)*dp[i-1&1][x-1][y+1][z];
	if (y) now += mint(y)*dp[i-1&1][x][y-1][z+1];
	// 3) 第 i 行用了 2 个棋子
	if (x > 1) now += mint(x)(x-1)/2 dp[i-1&1][x-2][y+2][z];
	if (y > 1) now += mint(y)(y-1)/2 dp[i-1&1][x][y-2][z+2];
	if (x) now += mint(x)y dp[i-1&1][x-1][y][z+1];
	dp[i&1][x][y][z] = now;
	}
	}

	cout << dp[n&1][m][0][0] << '\n';

	return 0;
	}

	#include <bits/stdc++.h>
	#define rep(i, n) for (int i = 0; i < (n); ++i)

	using namespace std;
	using ll = long long;

	template<typename T>
	inline void chmax(T& x, T y) { if (x < y) x = y; }

	int main() {
	int n;
	cin >> n;
	vector<int> p(n);
	rep(i, n) cin >> p[i];
	vector<int> sum(n+1);
	rep(i, n) sum[i+1] = sum[i]+p[i];

	int k;
	cin >> k;
	vector<int> v(k);
	rep(i, k) cin >> v[i];

	int k2 = 1<<k;
	vector<int> dp(k2);
	rep(s, k2) {
	rep(i, k) { // 枚举 k 张卡
	if (s>>i&1) { // 表示 state 中有这张卡，则考虑把这张卡作为最后一个使用的卡
	int x = dp[s^(1<<i)]; // 不使用第 i 张卡，最多买下前 x 件商品
	int now = upper_bound(sum.begin()+1, sum.end(), sum[x]+v[i]) - sum.begin()-1;
	chmax(dp[s], now);
	}
	}
	}

	ll ans = 0;
	bool ok = false;
	rep(s, k2) {
	if (dp[s] != n) continue;
	ok = true;
	ll money = 0;
	rep(i, k) if (~s>>i&1) money += v[i];
	chmax(ans, money);
	}

	if (ok) cout << ans << '\n';
	else puts("Balance is insufficient");

	return 0;
	}