A. The beautiful values of the palace
theme：给定一个n*n螺旋矩阵，现从螺旋矩阵中选出m个位置，每个位置的价值由它的元素值的每个数位之和表示，其余位置的元素全部置为0，q次询问，每次询问子矩阵价值。1<=n<=1e6,m,q<=1e5
solution:首先要根据螺旋矩阵的性质推出给定x,y,矩阵中(x,y)的元素值。之后问题转化为求二维矩阵的前缀和。n范围很大，所以借助树状数组辅助。
- 用一个结构体存每个点，包含成员变量flag:标志操作，0表示为将原数插入树状数组，1表示计算询问前缀和。x,y分别记录在矩阵中的横纵坐标。var:记录求子矩阵是时的正负号，即是加上一个前缀和还是减去。
- 将选出的点按y坐标优先，x坐标次之按从小到大排序。
- 排序后边查询边插入（树状数组将横坐标作为下标），按y坐标插入，这样算前缀和时算横坐标<=x的即可
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=(int)1e6+10;
ll bit[N],ans[N];
void Init(int n)
{
for(int i=1;i<=n;++i)
bit[i]=ans[i]=0;
}
/******************树状数组**************/
int lowbit(int x)
{
return x&(-x);
}
void add(int i,ll t)
{
while(i<=N)
{
bit[i]+=t;
i+=lowbit(i);
}
}
ll sum(int i)
{
ll sum=0;
while(i)
{
sum+=bit[i];
i-=lowbit(i);
}
return sum;
}
/******************矩阵**************/
struct node
{
int f;//标志是矩阵原数0插入还是求区间和时的ans+/-,1
int x,y,ans_id;
ll val;//标志求前缀和时是减掉还是加上该矩阵
friend bool operator<(node a,node b)//y,x,f
{
if(a.y==b.y)
{
if(a.x==b.x)
return a.f<b.f;
return a.x<b.x;
}
return a.y<b.y;
}
}p[N];
ll re_val(ll x)
{
ll sum=0;
while(x>0)
{
sum+=x%10;
x/=10;
}
return sum;
}
/************螺旋矩阵*************/
long long index(long long y,long long x,long long n)
{
long long mid=(n+1)/2;
long long p=max(abs(x-mid),abs(y-mid));
long long ans=n*n-(1+p)*p*4;
long long sx=mid+p,sy=mid+p;
if(x==sx&&y==sy)
return ans;
else
{
if(y==sy||x==sx-2*p)
return ans+abs(x-sx)+abs(y-sy);
else
return ans+8*p-abs(x-sx)-abs(y-sy);
}
}
/*************二位前缀和***************/
void solve(int n)
{
for(int i=1;i<=n;++i)
{
if(p[i].f) ans[p[i].ans_id]+=sum(p[i].x)*p[i].val;
else add(p[i].x,p[i].val);
}
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
int n,m,ask;
scanf("%d%d%d",&n,&m,&ask);
Init(N-3);
int cnt=0;
for(int i=1;i<=m;++i)
{
int x,y;
scanf("%d%d",&x,&y);
p[++cnt]={0,x,y,-1,re_val(index(x,y,n))};
}
for(int i=1;i<=ask;++i)
{
int xl,yl,xr,yr;
scanf("%d%d%d%d",&xl,&yl,&xr,&yr);
p[++cnt]={1,xl-1,yl-1,i,1};
p[++cnt]={1,xl-1,yr,i,-1};
p[++cnt]={1,xr,yl-1,i,-1};
p[++cnt]={1,xr,yr,i,1};
}
sort(p+1,p+1+cnt);
solve(cnt);
for(int i=1;i<=ask;++i)
printf("%lld\n",ans[i]);
}
return 0;
}
H. Holy Grail
theme:给定一个有向图，无重边与自环，无负环，可能有负权边，现依次询问6次，问在点s,t中间加一条s->t的边，边权尽可能小且加上这条边后图中没有负环。n<=300 , m<=500
solution：首先清楚负环是节点形成一个环，且环中所有边的权值之和<0。所以如果要加s->t的边部形成负环，则最少要是负的t->s的最短路，这样就算它们形成环，也不会是负环。由于要处理负权，不能用dijkstra,应用spfa。注意每次询问对后续询问有影响。
#include<bits/stdc++.h>
#include<vector>
#include<algorithm>
using namespace std;
#define far(i,t,n) for(int i=t;i<n;++i)
#define pk(a) push_back(a)
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
const int maxn=330;
ll inf=0x3f3f3f3f3f3f3f3f;
struct _a
{
int v;
ll w;
_a(int a,ll b)
{
v=a;
w=b;
}
};
vector<_a>V[maxn];
void addAdge(int u,int v,ll w)
{
V[u].push_back(_a(v,w));
}
bool vis[maxn];
ll dis[maxn];
void spfa(int start,int n)
{
fill(vis,vis+n+1,0);
fill(dis,dis+n+1,inf);
queue<int>q;
dis[start]=0;
q.push(start);
vis[start]=1;
while(!q.empty())
{
int u=q.front();
q.pop();
vis[u]=0;
int sz=V[u].size();
far(i,0,sz)
{
int v=V[u][i].v;
ll w=V[u][i].w;
if(dis[v]>dis[u]+w)
{
dis[v]=dis[u]+w;
if(!vis[v])
{
q.push(v);
vis[v]=1;
}
}
}
}
}
int main()
{
int t;
cin>>t;
while(t--)
{
int n,m;
scanf("%d%d",&n,&m);
far(i,0,n)
V[i].clear();
far(i,0,m)
{
int x,y;
ll w;
scanf("%d%d%lld",&x,&y,&w);
addAdge(x,y,w);
}
far(i,0,6)
{
int s,t;
scanf("%d%d",&s,&t);
spfa(t,n);
printf("%lld\n",-dis[s]);
addAdge(s,t,-dis[s]);
}
}
}
F. Greedy Sequence
theme:给定一个数组a,a为1~n的某个全排列，现构造n个递减序列，每个序列以i开始，序列中的数只能从a中选，且只能选一次，且要求相邻两个元素在数组a中的位置差的绝对值<=k,且有多重选择时选最大的。问每个序列能构造的长度？1<=n,k<=1e5
solution：这题实际上是求对于一个元素ai，假设它所处位置为i,则求[i-k,i+k]区间<i的最大值maxx，则ans[i]=ans[maxx]+1
求区间最大值想到用线段树维护，而又有一个限制要<=ai，所以我们可以按从小到大顺序将元素插入线段树，对于元素ai,查询它的时候线段树中才插入了1~ai-1，所以这时区间[i-k,i+k]最大值就是区间<=ai的最大值。
#include<bits/stdc++.h>
#include<vector>
#include<algorithm>
using namespace std;
#define far(i,t,n) for(int i=t;i<n;++i)
#define pk(a) push_back(a)
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
int tree[100010<<2];
void push_up(int rt)
{
tree[rt]=max(tree[rt<<1],tree[rt<<1|1]);
}
void update(int rt,int l,int r,int pos,int var)
{
if(l==r)
{
tree[rt]=var;
return;
}
int mid=(l+r)>>1;
if(pos<=mid)
update(rt<<1,l,mid,pos,var);
else
update(rt<<1|1,mid+1,r,pos,var);
push_up(rt);
}
int query(int rt,int l,int r,int L,int R)
{
if(L<=l&&r<=R)
return tree[rt];
int mid=(l+r)>>1;
int ans=0;
if(L<=mid)
ans=max(ans,query(rt<<1,l,mid,L,R));
if(R>mid)
ans=max(ans,query(rt<<1|1,mid+1,r,L,R));
return ans;
}
int a[100010];
int pos[100010];
int ans[100010];
int main()
{
int t;
cin>>t;
while(t--)
{
int n,k;
memset(tree,0,sizeof(tree));
scanf("%d%d",&n,&k);
for(int i=1;i<=n;++i)
scanf("%d",&a[i]),pos[a[i]]=i;
for(int i=1;i<=n;++i)
{
int l=max(1,pos[i]-k);
int r=min(n,pos[i]+k);
ans[i]=ans[query(1,1,n,l,r)]+1;
update(1,1,n,pos[i],i);
}
printf("%d",ans[1]);
for(int i=2;i<=n;++i)
printf(" %d",ans[i]);
puts("");
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
