(CSP-S2020)合集
A. 儒略日
这道题模拟能有(80pts)，可是考场上我不看题，花了将近三个小时敲大模拟(40pts)。
这道题实际上模拟的话可以分为公元前、1582.10.4、1582.10.5~1600.12.31，1600.12.31以后，为什么要分到$$1600.12.31$$为结点呢？后面每四百年蹦一次方便。
当然，我们也可以通过观察样例求解：
考虑到(P=3000000)天时恰好是(3501.8.15)，再往后蹦(400)年要(T)即(146097)天。暴力预处理这些天数。然后小于等于(C=3146097)的天数直接输出，大于的年月用(C+r\% T)天数输出，年份((r/T))加上((P+r\%T))代表的年份即可。
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<ctime>
#include<set>
#include<map>
#define CLR(x, y) memset(x,y,sizeof(x))
#define FOR(i, x, y) for(register int i=x;i<=y;++i)
#define ROF(i, x, y) for(register int i=x;i>=y;--i)
using namespace std;
const int C = 3146097, T = 146097, E = 3000000;
int D[C + 7], M[C + 7], Y[C + 7];
void init()
{
int day = 1, mon = 1, year = -4713;
bool op = true;
D[0] = 1, M[0] = 1, Y[0] = -4713;
FOR(i, 1, C)
{
++ day;
if(mon == 2) if((op && (day == 30)) || (op == false && (day == 29))) ++ mon, day = 1;
if(mon == 1 || mon == 3 || mon == 5 || mon == 7 || mon == 8 || mon == 10 || mon == 12)
if(day == 32) ++ mon, day = 1;
if(mon == 4 || mon == 6 || mon == 9 || mon == 11) if(day == 31) ++ mon, day = 1;
if(mon == 13) ++ year, mon = 1;
if(year == 0) year = 1;
if(year == 1582 && mon == 10 && day == 5) day = 15;
D[i] = day, M[i] = mon, Y[i] = year;
if(year < 0) op = (-year) % 4 == 1 ? true : false;
else
{
if(year < 1583) op = year % 4 == 0 ? true : false;
else op = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)? true:false;
}
}
return;
}
long long r;
int main()
{
int q;
scanf("%d", &q);
init();
while(q --)
{
scanf("%lld", &r);
if(r <= C)
{
printf("%d %d %d", D[r], M[r], abs(Y[r]));
if(Y[r] < 0) printf(" BC
");
else puts("");
}
else
{
int tmp = E + (r - E) % T;
printf("%d %d %d
", D[tmp], M[tmp], Y[tmp] + (r - E) / T * 400);
}
}
return 0;
}
B. 动物园
无语，竟然忘记特判了。(1)移(64)位就谁也救不了我了。
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<string>
#include<cstdio>
#include<cmath>
#include<bitset>
#include<queue>
#include<map>
#include<set>
#define ull unsigned long long
using namespace std;
const int N = 1000000 + 5;
bitset <100000000 + 5> table;
struct query
{
int p, q;
} Q[N];
int n, m, c, k;
ull a[N];
bool book[71] = {};
inline void read(ull &x)
{
bool mark = false;
char ch = getchar();
for(; ch < '0' || ch > '9'; ch = getchar()) if(ch == '-') mark = true;
for(x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = (x << 3) + (x << 1) + ch - '0';
if(mark) x = -x;
return;
}
int calc(ull x)
{
int res = 0;
while(x)
{
if(x & 1) ++ res;
x >>= 1;
}
return res;
}
int main()
{
table.reset();
scanf("%d %d %d %d", &n, &m, &c, &k);
ull P = 0;
for(int i = 1; i <= n; ++ i) read(a[i]);
for(int i = 1; i <= n; ++ i) P |= a[i];
for(int i = 0; i < m; ++ i)
{
scanf("%d %d", &Q[i].p, &Q[i].q);
if((P >> Q[i].p) & 1) table[Q[i].q] = true;
}
ull res = 0;
for(int i = 0; i < m; ++ i)
{
if(table[Q[i].q]) res |= 1ll << Q[i].p;
else book[Q[i].p] = true;
}
bool valid = false;
for(int i = 0; i < k; ++ i)
{
if(!book[i])
{
res |= 1ll << i;
}
else valid = true;
}
if(valid || k < 64)
{
int cnt = calc(res);
printf("%lld
", (1ll << cnt) - n);
}
else printf("18446744073709551616
");
return 0;
}
C. 函数调用
考场上不看题，暴力分都没拿到。
这道题模拟、暴力(20pts)。更优地，我们甚至可以将乘法累积到变量，加法乘该积数逆用于优化常数。
#include<iostream>
#include<cstring>
#include<vector>
#include<cstdio>
#include<cmath>
#define CLR(x, y) memset(x,y,sizeof(x))
#define FOR(i, x, y) for(register int i=x;i<=y;++i)
#define ROF(i, x, y) for(register int i=x;i>=y;--i)
#define pii pair<int,int>
using namespace std;
const int N = 200000 + 5, mod = 998244353;
struct Query
{
int t, p, v, c;
vector <int> g;
} q[N];
int n, m, Q, a[N], f[N];
template <typename T> void read(T &x)
{
bool mark = false;
char ch = getchar();
for(; ch < '0' || ch > '9'; ch = getchar()) if(ch == '-') mark = true;
for(x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = (x << 3) + (x << 1) + ch - '0';
if(mark) x = -x;
return;
}
void work(int p)
{
if(q[p].t == 1) a[q[p].p] = (a[q[p].p] + q[p].v) % mod;
else if(q[p].t == 2) FOR(i, 1, n) a[i] = 1ll * a[i] * q[p].v % mod;
else FOR(i, 0, q[p].g.size() - 1) work(q[p].g[i]);
return;
}
int main()
{
read(n);
FOR(i, 1, n) read(a[i]);
read(m);
FOR(i, 1, m)
{
read(q[i].t);
switch(q[i].t)
{
case 1:
{
read(q[i].p), read(q[i].v);
break;
}
case 2:
{
read(q[i].v);
break;
}
case 3:
{
read(q[i].c);
FOR(j, 1, q[i].c)
{
int tmp;
read(tmp);
q[i].g.push_back(tmp);
}
break;
}
}
}
read(Q);
FOR(i, 1, Q) read(f[i]);
FOR(i, 1, Q) work(f[i]);
FOR(i, 1, n) printf("%d ", a[i]);
puts("");
return 0;
}
假设操作序列中只有加法或乘法操作，那么调用顺序毫无影响。
对于加法操作，我们只需要把每个函数对序列的影响记录下来，计算每一位上的数的变量。具体来说，我们可以根据调用关系建立一张DAG，按照拓扑序计算出每一个加法操作被调用次数，对于每一个加法操作函数，可以记录它更新的位置，统计时将该位置上的数加上总次数即可。
乘法操作虽则如出一辙，但我们对于该问题，有不一样的解法。考虑计算每一个函数所产生的乘积贡献值，将所有调用的函数乘积贡献值（即(dp1[i])）统计一下即可。
我们将问题转化：对于每一个数(a_i)，先不考虑加的数对它的影响，它最终的答案就是总乘积乘该数。那么，该问题变为了对于每一个加法操作对整个序列的影响统计，可以考虑模拟的整个过程。
该过程中，会发现，设第(f_i)个为加法操作，那么，对于后面的所有的(f_j(j>i))，它们的乘法贡献一定会作用于第(f_i)个操作的值，最后统计即可。也就是说(val*mul)。
为了能够统计后面的乘积，使其能够对前面有影响，我们倒序进行。
时间复杂度降低为(O(Q*m))。
#include<iostream>
#include<cstring>
#include<vector>
#include<cstdio>
#include<cmath>
#define CLR(x, y) memset(x,y,sizeof(x))
#define FOR(i, x, y) for(register int i=x;i<=y;++i)
#define ROF(i, x, y) for(register int i=x;i>=y;--i)
using namespace std;
const int N = 100000 + 5, M = 100000 + 5, mod = 998244353;
typedef long long LL;
vector <int> G[M];
int n, m, f[N], p[M], type[M];
LL a[N], mul = 1, v[M], add[N];
void dfs(int u)
{
if(type[u] == 1)
{
add[p[u]] = (add[p[u]] + 1ll * v[u] * mul % mod) % mod;
return;
}
if(type[u] == 2)
{
mul = 1ll * mul * v[u] % mod;
return;
}
int v;
for(int i = G[u].size() - 1; i >= 0; -- i)
{
v = G[u][i];
dfs(v);
}
return;
}
template <typename T> void read(T &x)
{
bool mark = false;
char ch = getchar();
for(; ch < '0' || ch > '9'; ch = getchar()) if(ch == '-') mark = true;
for(x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = (x << 3) + (x << 1) + ch - '0';
if(mark) x = -x;
return;
}
int main()
{
read(n);
FOR(i, 1, n) read(a[i]);
read(m);
FOR(i, 1, m) G[i].clear();
FOR(i, 1, m)
{
read(type[i]);
switch(type[i])
{
case 1:
read(p[i]), read(v[i]);
break;
case 2:
read(v[i]);
break;
case 3:
int tmp;
read(tmp);
G[i].resize(tmp);
FOR(j, 0, tmp - 1) read(G[i][j]);
break;
default: break;
}
}
int T;
read(T);
FOR(i, 1, T) read(f[i]);
CLR(add, 0);
int u;
ROF(i, T, 1)
{
u = f[i];
if(type[u] == 1) add[p[u]] = (add[p[u]] + v[u] * mul) % mod;
else if(type[u] == 2) mul = 1ll * mul * v[u] % mod;
else dfs(u);
}
FOR(i, 1, n) printf("%lld ", (1ll * a[i] * mul % mod + add[i]) % mod);
puts("");
return 0;
}
这样做并不是最好的。
考虑：一个加法被乘(k)次，相当于该函数被调用(k)次。
而函数的“调用函数”被调用的次数需要累加到该函数内。
定义一个数组(dp[u])代表结点被调用了几次。
如果该节点是个乘法调用，不用理它，因为乘法我们已经计算完了；如果是一个“调用函数”那么，接下来的步骤，就是来解决内部的函数调用的统计；如果是一个加法调用，可以累加到(add[i])第(i)位影响。
接下来，我们统计所有在“调用函数”中被调用的函数调用次数。
拓扑排序。
不过，在TOP过程中，要随时记录乘积，更新调用次数；另外，对于一个“调用函数”的调用顺序，可以倒序求解。
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#define CLR(x, y) memset(x,y,sizeof(x))
#define FOR(i, x, y) for(register int i=x;i<=y;++i)
#define ROF(i, x, y) for(register int i=x;i>=y;--i)
using namespace std;
const int N = 100000 + 5, M = 1000000 + 5, mod = 998244353;
typedef long long LL;
template <typename T> void read(T &x)
{
bool mark = false;
char ch = getchar();
for(; ch < '0' || ch > '9'; ch = getchar()) if(ch == '-') mark = true;
for(x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = (x << 3) + (x << 1) + ch - '0';
if(mark) x = -x;
return;
}
struct Query
{
int type, P, V;
int C;
} q[N];
vector <int> G[N];
queue <int> Q;
int n, m, T, f[M], deg[N];
LL mul = 1, a[N], add[N], prob[N], dp[N];// dp stands for the times that a function has been called
void dfs(int u)
{
if(prob[u] != -1) return;
prob[u] = 1;
if(q[u].type == 1) return;
if(q[u].type == 2)
{
prob[u] = q[u].V;
return;
}
reverse(G[u].begin(), G[u].end());
int v;
for(int i = 0; i < G[u].size(); ++ i)
{
v = G[u][i];
dfs(v);
prob[u] = 1ll * prob[u] * prob[v] % mod;
}
return;
}
int main()
{
read(n);
FOR(i, 1, n) read(a[i]);
read(m);
FOR(i, 1, m) G[i].clear();
CLR(deg, 0);
int tmp;
FOR(i, 1, m)
{
read(q[i].type);
switch(q[i].type)
{
case 1:
read(q[i].P), read(q[i].V);
break;
case 2:
read(q[i].V);
break;
case 3:
read(q[i].C);
FOR(j, 1, q[i].C)
{
read(tmp);
G[i].push_back(tmp);
++ deg[tmp];
}
break;
default: break;
}
}
CLR(prob, -1);
FOR(i, 1, m) dfs(i); // calculate the product of each function
read(T);
FOR(i, 1, T) read(f[i]);
int u, v;
LL w;
ROF(i, T, 1)
{
u = f[i];
dp[u] = (dp[u] + mul) % mod;
if(q[u].type == 2 || q[u].type == 3) mul = 1ll * prob[u] * mul % mod;
}
while(Q.size()) Q.pop();
FOR(i, 1, m)
if(!deg[i]) Q.push(i);
while(Q.size())
{
u = Q.front(); Q.pop();
if(q[u].type == 1) add[q[u].P] = (add[q[u].P] + 1ll * dp[u] * q[u].V % mod) % mod;
w = dp[u];
for(int i = 0; i < G[u].size(); ++ i)
{
v = G[u][i];
-- deg[v];
if(!deg[v]) Q.push(v);
dp[v] = (dp[v] + w) % mod;
w = 1ll * w * prob[v] % mod;
}
}
FOR(i, 1, n) printf("%d ", (1ll * a[i] * mul % mod + add[i]) % mod);
puts("");
return 0;
}