目录
A
B
C
D
E
F
G(待补充)
H
I(待补充)
J(待补充)
K
L
M
A
题意
如上图所示，n个人在x轴上向对面射出激光，
激光碰到水平玻璃壁后会从水平玻璃壁两端继续向上传递。
给出q个水平玻璃壁，保证没有重合、相交、越界的水平玻璃壁，
问最终会击中多少个位置。
题解
用set保存激光位置，
把玻璃壁按y从小到大排序，依次处理。
对于每个玻璃壁，二分找到最左端的在上面的激光和最左端的不在上面的激光，
依次把这些激光删除后在左右两端插入新的激光即可，
注意玻璃壁上没有激光时不会射出新的激光。
粗略估计复杂度为O(nlognlogn)（？）
用线段树/分块也可实现。
代码
struct Solver {
void solve() {
cin >> n >> q;
set st;
vector vn (q);
for (int i = 1; i <= n; ++i) {
st.insert(i);
}
for (int i = 0; i < q; ++i) {
cin >> vn[i].x1 >> vn[i].x2 >> vn[i].y;
}
std::sort(vn.begin(), vn.end());
for (int i = 0; i < q; ++i) {
auto its = st.lower_bound(vn[i].x1);
auto ite = st.upper_bound(vn[i].x2);
if (its != ite) mark = 1;
else mark = 0;
while (its != st.end() && its != ite) {
st.erase(its++);
}
if (mark) st.insert(vn[i].x1), st.insert(vn[i].x2);
}
cout << st.size() << '\n';
}
};
B
题意
给出一个n*m的矩阵，要求若干次“ *** 作”后使得矩阵每行、每列之和均非负
“ *** 作”的定义为选择一行/一列，使得该行/列上的每个数都变为自己的相反数（即乘上-1）。
题解
枚举每行每列，每次对于和最小的某行/某列进行 *** 作，若干次后即可满足题意。
代码
#include
using namespace std;
using ll = long long;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while(t--) {
int n, m;
cin >> n >> m;
vector> a(n + 1, vector(m + 1, 0));
vector r(n + 1), c(m + 1);
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++) {
cin >> a[i][j];
r[i] += a[i][j];
c[j] += a[i][j];
}
}
vector vr(n + 1), vc(m + 1);
int cnt = n + m;
int ok = 1;
while(cnt--) {
int fl = -1;//0 : r 1 : c
int id = 0;
int mi = 0x3f3f3f3f;
for(int i = 1; i <= n; i++) {
if (r[i] < 0 && r[i] < mi) fl = 0, mi = r[i], id = i;
}
for(int i = 1; i <= m; i++) {
if(c[i] < 0 && c[i] < mi) fl = 1, mi = c[i], id = i;
}
if(fl == -1) {
ok = 1;
break;
}
if(fl == 0) {
vr[id] ^= 1;
for(int i = 1; i <= m; i++) {
c[i] -= 2 * a[id][i];
r[id] -= 2 * a[id][i];
a[id][i] = -a[id][i];
}
}
if(fl == 1) {
vc[id] ^= 1;
for(int i = 1; i <= n; i++) {
r[i] -= 2 * a[i][id];
c[id] -= 2 * a[i][id];
a[i][id] = -a[i][id];
}
}
/*
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++) {
cout << a[i][j] << ' ';
}
cout << '\n';
}
cout << "----------" << '\n';
for(int i = 1; i <= n; i++) cout << r[i] << ' ';cout << '\n';
cout << "----------" << '\n';
for(int i = 1; i <= m; i++) cout << c[i] << ' ';cout << '\n';
cout << "----------" << '\n';
*/
}
if(!ok) ;
else {
cout << "Yes" << '\n';
vector ansr, ansc;
for (int i = 1; i <= n; i++) if (vr[i]) ansr.push_back(i);
for (int i = 1; i <= m; i++) if (vc[i]) ansc.push_back(i);
cout << ansr.size() << '\n';
for(int i = 0; i < ansr.size(); i++) cout << ansr[i] << ' ';cout << '\n';
cout << ansc.size() << '\n';
for(int i = 0; i < ansc.size(); i++) cout << ansc[i] << ' ';cout << '\n';
}
}
return 0;
}
C
题意
给出n个互不相同的数，判断是否有序
题解
签中之签，is_sorted秒切
代码
struct Solver {
void solve() {
cin >> n;
vector ve(n);
for (int i = 0; i < n; i++) {
cin >> ve[i];
}
cout << (std::is_sorted(ve.begin(), ve.end()) ? "Yes" : "No") << '\n';
}
};
D
题意
给出两个长度为n的数组，形如下：
A: {1, 2, 3, ..., n}
B: {2, 3, 4, ..., n+1}
要求交换若干次AB数组中相同下标的数之后使得
A数组所有元素的乘积 = B数组所有元素的乘积
题解
记表示A数组所有元素的乘积，
第i位的上下交换(i>0)会使得的值变为原来的倍，
易知的初始值为，经过暴力枚举后可知，
当且仅当n是一个完全平方数时有解，即从1交换到。
代码
#include
using namespace std;
using ll = long long;
const int MaxN = 1e5 + 7;
const int mod = 1e9 + 7;
const int Inv2 = 5e8 + 4;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
/*
暴力枚举
int n;
cin >> n;
vector a(n), b(n);
for(int i = 0; i < n; i++) {
a[i] = i + 1, b[i] = i + 2;
}
for(int i = 0; i < 1 << n; i++) {
ll up = 1, down = 1;
for(int j = 0; j < n; j++) {
if(i >> j & 1) up *= b[j], down *= a[j];
else up *= a[j], down *= b[j];
}
if(up == down) {
for(int j = 0; j < n; j++) {
if(i >> j & 1) cout << j + 1 << ' ';
}
cout << '\n';
}
}
*/
map mp;
for(int i = 1; i <= 5000; i++) mp[i * i] = i;
int t;
cin >> t;
while(t--) {
int n;
cin >> n;
n += 1;
if(mp.count(n)) {
int x = mp[n];
cout << x -1 << '\n';
for(int i = 1; i < x; i++) {
cout << i << " \n"[i == x - 1];
}
}
else cout << -1 << '\n';
}
return 0;
}
E
题意
一个机器人在长度为N的线上巡逻，
先向右走到第一个未被巡逻过的格子，
再向左走到第一个未被巡逻过的格子，
重复直到所有格子都被巡逻完毕，
求最小步数。
题解
签到，输出即可
即
代码
struct Solver {
void solve() {
ll n;
cin >> n;
cout << n*(n-1)/2 << '\n';
}
};
F
题意
输出七个数的和
代码
#include
using namespace std;
using ll = long long;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while(t--) {
int ret = 0;
for(int i = 1; i <= 7; i++) {
int c;
cin >> c;
ret += c;
}
cout << ret << '\n';
}
return 0;
}
G(待补充)
题意
给出一个n*m的矩阵，矩阵中上下左右相邻且相同的点连接在一起
有两种 *** 作：
1 *** 作给出一个矩形的左上和右下，问这个矩形里有多少个完整的连通块和部分的连通块
2 *** 作删除一个点，删除后不能连通且不被视作连通块
题解(待补充)
代码(待补充)
H
题意
定义 FAT 为集合中的每个数都不小于集合的size的集合，
问用1~n可以构造出多少个 FAT。
题解
递推预处理即可
代码
vector dp(100001);
dp[1] = 1, dp[2] = 2;
for(int i = 3; i <= 100000; i++) {
dp[i] = (dp[i - 1] + dp[i - 2] + 1) % mod;
} I(待补充)
题意
给出n个点，每个点有一个存在的概率
要求用一个最小的边和水平线竖直线平行的矩形囊括所有的存在的点
求矩形面积的期望
题解(待补充)
代码(待补充)
J(待补充)
题意
给出n个有颜色的球，相同颜色的球等价
把n个球放到m个不等价的盒子里
问每个盒子里都有球的方案数
题解(待补充)
代码(待补充)
K
题意
有n场最晚k点结束的电影，求所有的L、R时间区间完整看完2场电影的方法数之和
注：[1,3]电影与[3,5]电影不能一起看，[1,3]和[4,5]则可以
题解
支持单点修改&区间查询的数据结构(树状数组/线段树)可以很方便的做出这道题
每场电影都会对在它结束后才开始的电影有贡献，贡献为开始时间
全部贡献统计完成后，
对于每场电影用1~开始时间这段区间里的贡献乘上大于等于结束时间的R的可能性个数
即可统计以当前这场电影作为第二场电影的贡献总数。
全部相加即为答案。
注意取模
代码
#define TYPE_ ll
int MAXN = 200005;
vector tree; //**tree下标从1开始
TYPE_ lowbit(TYPE_ x) { return x & (-x); }
void upd(int id, ll val) {
while (id < MAXN) {
(tree[id] += val) %= mod;
id += lowbit(id);
}
}
ll query(int id) {
ll res = 0;
while (id) {
(res += tree[id]) %= mod;
id -= lowbit(id);
}
return res;
}
struct Solver {
void solve() {
cin >> n >> m;
MAXN = m+5;
tree = vector (MAXN);
vector > vp(n);
for (int i = 0; i < n; i++) {
cin >> vp[i].first >> vp[i].second;
upd(vp[i].second+1, vp[i].first);
}
ans = 0;
for (int i = 0; i < n; ++i) {
(ans += query(vp[i].first) * (m - vp[i].second + 1)) %= mod;
}
cout << ans << '\n';
}
};
L
题意
给出n个数，要求找到一个最长的连续的奇数/偶数段的长度不大于k的子序列。
题解
dp[i][j]，状态为[奇数/偶数][在结尾连续出现j次]，转移即可
复杂度O(n*k)
代码
struct Solver {
void solve() {
cin >> n >> k;
vector ve(n);
vector > dp (2, vector (k));
for (int i = 0; i < n; i++) {
cin >> ve[i];
}
ans = ve[0];
dp[0][0] = (ve[0] & 1 ? 0 : ve[0]);
dp[1][0] = (ve[0] & 1 ? ve[0] : 0);
for (int i = 1; i < n; ++i) {
int op = ve[i] & 1;
for (int j = k-1; j >= 1; --j) {
dp[op][j] = max(dp[op][j], dp[op][j-1] + ve[i]);
}
dp[op][0] = max(dp[op][0], *std::max_element(dp[!op].begin(), dp[!op].end()) + ve[i]);
ans = max(ans, *std::max_element(dp[op].begin(), dp[op].end()));
}
cout << ans << '\n';
}
};
M
题意
设，求长度为n的所有排列的之和
人话：在长度为n的所有排列中存在多少对数，
使得这对数中的后面的一个数能被前面的一个数整除。
题解
在排列中的位置只有两种情况，
即x在前y在后，或y在前x在后，两种情况出现的频率均为
所以对于任意一对数，它们对于整体的贡献为
所以只要预处理出与前n个数中存在多少对即可O(1)算出答案
代码
const int mod = 1e9+7, inv2 = 500000004;
vector fac(100005, 1), pre(100005, 1);
void init() {
for (int i = 2; i <= 100000; ++i) {
fac[i] = fac[i-1] * i % mod;
}
pre[0] = pre[1] = 0;
for (int i = 2; i <= 50000; ++i) {
for (int j = i*2; j <= 100000; j += i) {
pre[j]++;
}
}
for (int i = 2; i <= 100000; ++i) {
(pre[i] += pre[i-1]) %= mod;
}
}
struct Solver {
void solve() {
cin >> n;
cout << fac[n] * pre[n] % mod * inv2 % mod << '\n';
}
}; 欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）