A. The beautiful values of the palace
题意：
有一个n*n的蛇形矩阵，如下图
矩阵的左下角的坐标是(1,1)，右上角是(n,n)
每个格子的权值是这个格子中的数的数位和
现在给出m个坐标，标记这些点
q次询问，每次给出一个矩形坐标，问这个矩形里标记的点的权值和
n<=1e6，m,q<=1e5，保证n是奇数
解法：
子矩阵权值和问题扫描线思想+树状数组离线乱搞一下就行了
关键是如何计算每个格子里面的值，需要找规律推式子，
先判断在哪一圈，然后判断在哪一侧，分类讨论即可。
由于我太懒了，遂copy了别人的结论：
ll getval(ll x, ll y, ll n) {
ll t = min(min(x, y), min(n - x + 1, n - y + 1));
ll ta = 4 * (t - 1) * (n - t + 1);
if (x == n - t + 1) ta += n - t - y + 2;//在所在圈层的右侧边
else if (x == t) ta += 2 * n - 5 * t + y + 3;//左侧边
else if (y == t) ta += 2 * n - 3 * t - x + 3;//下侧边
else ta += 3 * n - 7 * t + x + 4;//上侧边
return ta;
}
ps：
另一种做法：
将m个点看成m个加点操作
将询问拆成4个子矩阵询问，拆完之后变成4个(x,y)
对于每个询问(x,y)，有贡献的点(x1,y1)需要满足：
1.x1<=x
2.y1<=y
3.坐标相同时加点操作要在修改操作之前，所以flag(加点)和flag(查询)也有一个大小关系
这是一个三维偏序问题，可以用cdq分治做。
不过我没试过，这种方法写起来太麻烦了。
code：
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxm=1e6+5;
struct BIT{
int c[maxm];
void clear(){
memset(c,0,sizeof c);
}
int lowbit(int i){
return i&-i;
}
void add(int i,int t){
while(i<maxm)c[i]+=t,i+=lowbit(i);
}
int ask(int i){
int ans=0;
while(i)ans+=c[i],i-=lowbit(i);
return ans;
}
}T;
struct Q{
int x,y,flag,id;
}q[maxm<<2];
struct P{
int x,y,val;
}p[maxm];
bool cmpQ(Q a,Q b){
return a.x<b.x;
}
bool cmpP(P a,P b){
return a.x<b.x;
}
int ans[maxm];
int n,m,k;
ll getval(ll x, ll y, ll n) {
ll t = min(min(x, y), min(n - x + 1, n - y + 1));
ll ta = 4 * (t - 1) * (n - t + 1);
if (x == n - t + 1) ta += n - t - y + 2;//在所在圈层的右侧边
else if (x == t) ta += 2 * n - 5 * t + y + 3;//左侧边
else if (y == t) ta += 2 * n - 3 * t - x + 3;//下侧边
else ta += 3 * n - 7 * t + x + 4;//上侧边
return ta;
}
int cal(ll x){//数位和
int ans=0;
while(x)ans+=x%10,x/=10;
return ans;
}
signed main(){
int Cas;scanf("%d",&Cas);
while(Cas--){
T.clear();
//
scanf("%d%d%d",&n,&m,&k);
for(int i=1;i<=m;i++){
int x,y;scanf("%d%d",&x,&y);
p[i]={x,y,cal(getval(x,y,n))};
}
sort(p+1,p+1+m,cmpP);
int num=0;
for(int i=1;i<=k;i++){
int x1,y1,x2,y2;scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
q[++num]={x1-1,y1-1,1,i};
q[++num]={x1-1,y2,-1,i};
q[++num]={x2,y1-1,-1,i};
q[++num]={x2,y2,1,i};
}
sort(q+1,q+1+num,cmpQ);
//
for(int i=1;i<=k;i++){
ans[i]=0;
}
int now=1;
for(int i=1;i<=num;i++){
while(now<=m&&p[now].x<=q[i].x){
T.add(p[now].y,p[now].val);
now++;
}
ans[q[i].id]+=q[i].flag*T.ask(q[i].y);
}
for(int i=1;i<=k;i++){
printf("%d\n",ans[i]);
}
}
return 0;
}
B.super_log
题意：
函数定义：
给定a，b，m
要求找到最小的x，满足log*a(x)>=b，
因为x会很大，所以将答案对m取模
数据范围：a,b,m<=1e6
解法：
容易猜到x肯定和a有关
当x=1的时候，值为0
当x=a的时候，值为1
当x=aa的时候，值为2
可以推出满足log*a(x)>=b的最小x就是:
一共b个a
递归进行欧拉降幂就行了
降幂公式：
当不保证互质的时候，降幂过程需要比较b和phi[p]的大小然后分情况，但是b很大，不好比较，
这篇博客中介绍了一种精妙的取模方法：
int mo(long long x,int mod) {return x<mod?x:x%mod+mod;}
这是在比较b和phi[p]的大小，如果b<phi[p]，返回b；否则返回b%phi[p]+phi[p]。
（其他地方看到的一个说法：保留一个phi[p]是为了保证取模之后仍然满足欧拉降幂的公式，防止把原本大于phi[p]的数取模之后变为小于phi[p]）
那么式子变为：
将solve函数和快速幂函数中的取模都替换成这个。
最后得到的答案需要加一个正常的%mod
code：
#include<bits/stdc++.h>
using namespace std;
const int maxm=1e6+5;
int notprime[maxm];
int prime[maxm],cnt;
int phi[maxm];
int a,b,m;
int mo(long long x,int mod){//所有取模的地方换成这个
return x<mod?x:x%mod+mod;
}
void init(){//phi打表
phi[1]=1;
for(int i=2;i<maxm;i++){
if(!notprime[i]){
prime[cnt++]=i;
phi[i]=i-1;
}
for(int j=0;j<cnt;j++){
if(1LL*prime[j]*i>=maxm)break;
notprime[prime[j]*i]=1;
phi[prime[j]*i]=phi[i]*(i%prime[j]?prime[j]-1:prime[j]);
if(i%prime[j]==0)break;
}
}
}
int ppow(int a,int b,int mod){
int ans=mo(1,mod);a=mo(a,mod);
while(b){
if(b&1)ans=mo(1LL*ans*a,mod);
a=mo(1LL*a*a,mod);
b>>=1;
}
return ans;
}
int solve(int a,int b,int m){
if(m==1)return mo(a,m);
if(b==0)return mo(1,m);
if(b==1)return mo(a,m);
return ppow(a,solve(a,b-1,phi[m]),m);
}
signed main(){
init();
//
int T;scanf("%d",&T);
while(T--){
scanf("%d%d%d",&a,&b,&m);
printf("%d\n",solve(a,b,m)%m);//这里要加一个%m
}
return 0;
}
D.Robots
题意：
给定n个顶点m条边的有向无环图
一个机器人从1出发，有等概率走任意一条出边或者原地不动,每次移动需要能量，能量大小等于当前经过的天数，求从1到n的能量消耗期望
数据范围：n,m<=2e5
解法：
F. Greedy Sequence
题意：
给定长度为n的排列A，1<=A[i]<=n,找出n个串S满足5个条件：
1：S(i,1)=i
2：S(i,j)<=S(i,j-1)(就是单调不增)
3：S中相邻元素在数组A中的下标绝对值<=k
4：S的字典序最大
5：A中的每个元素只能使用一次。
输出每个串的长度
解法：
S(i,1)=i，字典序最大，那么S(i,2)就是找[pos-k,pos+k]内<i的最大值，以此类推
计算区间内<i的最大值可以用主席树搞
H.Holy Grail
题意：
n个点m条带权有向边，保证无自环和重边，边权可能是负数
然后给出6组数x,y，保证x到y没有边，
现在要求在x到y上加一条带权有向边，问每次所加权值最小为多少（可以是负数），
满足加边之后图中不能有负环，并将这条边加入图中。
数据范围：n<=300，m<=500
解法：
计算出反向边y到x的最短路，然后取相反值就是答案，这样环的权值为0，刚好没有负环
由于点的数量比较小，最短路可以直接用floyd做
code：
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int maxm=505;
const int inf=1e17;
int d[maxm][maxm];//原图
int g[maxm][maxm];//最短路图
int n,m;
void floyd(){
for(int k=0;k<n;k++){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(i==j||i==k||j==k)continue;
g[i][j]=min(g[i][j],g[i][k]+g[k][j]);
}
}
}
}
signed main(){
ios::sync_with_stdio(0);
int T;cin>>T;
while(T--){
cin>>n>>m;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(i==j)continue;
d[i][j]=inf;
}
}
for(int i=1;i<=m;i++){
int a,b,c;cin>>a>>b>>c;
d[a][b]=c;
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
g[i][j]=d[i][j];
}
}
for(int k=1;k<=6;k++){
floyd();
int a,b;cin>>a>>b;
cout<<-g[b][a]<<endl;
d[a][b]=-g[b][a];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
g[i][j]=d[i][j];
}
}
}
}
return 0;
}
1587
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
