比赛链接：https://ac.nowcoder.com/acm/contest/947#question
A:这道题要考虑的全面一点，中间点的情况全部都要考虑进去，所以我把确定点之前能填的点全部填上，最后算0的个数和-1的个数
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
#define ll long long
const int ding=200;
int a[ding];
int main()
{
std::ios::sync_with_stdio(false);
int n,flag=1,ans=0,one=0,i;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d",&a[i]);
}
if(a[1]!=0&&a[1]!=-1)flag=0;
int cnt=-1;
for(i=n;i>=1;i--){
if(a[i]!=-1){
cnt=a[i];
}
else{
if(cnt!=-1&&cnt!=0){
cnt--;
a[i]=cnt;
}
}
}
a[1]=0;
for(i=1;i<=n;i++){
if(a[i]==0){
cnt=0;
}
else{
cnt++;
if(a[i]!=cnt&&a[i]!=-1){
flag=0;
}
}
}
if(flag){
for(i=1;i<=n;i++){
if(a[i]==0)ans++;
if(a[i]==-1)one++;
}
printf("%d %d\n",ans,ans+one);
}
else printf("-1\n");
return 0;
}B:确定的奶牛的挤奶位置就直接填上，然后我把一系列顺序以1为分界线分成两边，1右边的点尽可能往右边放，1左边的点尽可能的往左边放，如果1没出现，那么默认1是第一顺序挤奶，放完之后根据1左边一位和右边一位的限制区间，找一个最早挤奶的位置，还有就是 搜之前要先确定第一个和最后一个的最左或最右顺序，不然其他的都没办法确定。
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
#define ll long long
const int ding=105;
struct node{
int val,posi;
// node(){
// val=posi=0;
// }
}a[ding];
int cow[ding],posi[ding];
int main()
{
std::ios::sync_with_stdio(false);
int n,m,k,aa,b,i,flag1=0,j;
scanf("%d %d %d",&n,&m,&k);
// a[1].val=1;
for(i=1;i<=m;i++){
scanf("%d",&a[i].val);
}
for(i=0;i<k;i++){
scanf("%d %d",&aa,&b);
if(aa==1){
flag1=1;
}
cow[aa]=b;
posi[b]=aa;
}
if(flag1){
printf("%d\n",cow[1]);
return 0;
}
// if(flag){
//
// }
if(a[m].val!=1){
if(cow[a[m].val]>0)
a[m].posi=cow[a[m].val];
else {
int k=n;
while(posi[k]){
k--;
}
a[m].posi=k;
posi[k]=a[m].val;
cow[a[m].val]=k;
}
}
for(i=m;i>=1;i--){
if(a[i].val==1)break;
if(cow[a[i].val]>0){
a[i].posi=cow[a[i].val];
}
else{
if(a[i+1].posi>0){
int j=a[i+1].posi-1;
// printf("j %d %d\n",a[i].val,j);
while(j>0&&posi[j]){
j--;
}
a[i].posi=j;
posi[j]=a[i].val;
cow[a[i].val]=j;
}
}
}
// printf("iii %d\n",i);
if(1<i){
if(cow[a[1].val])
a[1].posi=cow[a[1].val];
else {
int k=1;
while(posi[k]){
k++;
}
a[1].posi=k;
posi[k]=a[1].val;
cow[a[1].val]=k;
}
}
for(j=1;j<i;j++){
if(cow[a[j].val]>0){
a[j].posi=cow[a[j].val];
}
else{
if(a[j-1].posi>0){
int k=a[j-1].posi+1;
// printf("j %d %d\n",a[i].val,j);
while(k<=n&&posi[k]){
k++;
}
a[j].posi=k;
posi[k]=a[j].val;
cow[a[j].val]=k;
}
}
}
// for(i=1;i<=n;i++){
// printf("posi %d\n",posi[i]);
// }
int L=1,R=n;
for(i=1;i<=m;i++){
if(a[i].val==1){
if(i<m)R=a[i+1].posi-1;
if(i>1)L=a[i-1].posi+1;
break;
}
}
for(i=L;i<=R;i++){
if(posi[i]==0){
printf("%d\n",i);
break;
}
}
return 0;
}D:分数规划+01背包
然后二分答案，判断答案是否成立的时候
用01背包求这个式子的最大值
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
#define ll long long
ll dp[1500],w[1500],t[1500];
int n;
ll weight;
const ll INF=0x3f3f3f3f3f3f3f3f;
int check(ll mid){
int i,j,wei;
memset(dp,-INF,sizeof(dp));
dp[0]=0;
for(i=1;i<=n;i++){
for(j=weight;j>=0;j--){
if(dp[j]!=-INF){
wei=min(j+w[i],weight);
dp[wei]=max(dp[wei],dp[j]+t[i]-mid*w[i]);
}
}
}
if(dp[weight]>0)return 1;
return 0;
}
int main()
{
// std::ios::sync_with_stdio(false);
ll ans=0;
int i;
scanf("%d %lld",&n,&weight);
for(i=1;i<=n;i++){
scanf("%lld %lld",&w[i],&t[i]);
t[i]*=1000;
}
ll L=0,R=1000000;
while(L<=R){
ll mid=(L+R)/2;
if(check(mid)){
ans=mid;
L=mid+1;
}
else R=mid-1;
}
printf("%lld\n",ans);
return 0;
}F:
暴力枚举每个起点，求最小值
求每个起点的价值时，用优先队列，在当前点，从优先队列中取出一个最远的点，那里的牛放进当前点，
因为 a^2+b^2<(a+b)^2
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
#define ll long long
const int ding=1005;
int init[2*ding];
priority_queue<int,vector<int>,greater<int> >q;
int main()
{
std::ios::sync_with_stdio(false);
int n,ans=0x3f3f3f3f,i,sum,flag,j;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d",&init[i]);
init[i+n]=init[i];
}
for(i=1;i<=n;i++){
sum=0,flag=0;
while(!q.empty())q.pop();
for(j=i;j<=i+n-1;j++){
if(q.size()==0&&init[j]==0){
flag=1;
break;
}
int cnt=init[j];
while(cnt--)q.push(j);
int v=q.top();
q.pop();
// printf("jjjj %d %d\n",j,v);
sum+=(j-v)*(j-v);
}
if(flag)continue;
// printf("cnt %d\n",cnt);
ans=min(ans,sum);
}
printf("%d\n",ans);
return 0;
}H:BFS
每次BFS的时候先把当前点可以打开的灯全部打开，然后判断打开灯的房间是否可以走，就是判断他的上下左右是否已经访问过了，如果已经访问过了，说明当前点也可以访问，扔进队列
然后再判断当前点的上下左右的房间是否有打开灯之后没访问过的，如果有扔进队列
主要是存在打开灯，但是还不能访问的房间，可能后面把他旁边的房间的灯打开才可以访问
还有就是存在当前可以访问的房间，但是还没有打开灯
所以BFS有所不同
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
#define ll long long
const int ding=1e5;
struct node{
int x,y;
};
int vis[105][105],lighten[105][105];
int d[4][2]={1,0,-1,0,0,1,0,-1},n;
vector<int>mp[ding];
queue<node>q;
//void init(){
// for(i=1;i<=100;i++){
// for(j=1;j<=100;j++){
// index[i][j]=i*100+j;
// }
// }
//}
int access(int x,int y){
int i;
for(i=0;i<4;i++){
int xx=x+d[i][0];
int yy=y+d[i][1];
// printf("xxx %d %d\n",xx,yy);
if(xx<=n&&xx>0&&yy<=n&&yy>0&&vis[xx][yy]){
return 1;
}
}
return 0;
}
void BFS(){
int i;
vis[1][1]=1;
lighten[1][1]=1;
int ans=1;
q.push((node){1,1});
while(!q.empty()){
node v=q.front();
q.pop();
int tocor=(v.x-1)*n+v.y;
// printf("torcor %d\n",tocor);
for(i=0;i<mp[tocor].size();i++){
node tmp;
tmp.x=(mp[tocor][i]-1)/n+1;
tmp.y=mp[tocor][i]-(tmp.x-1)*n;
if(!lighten[tmp.x][tmp.y]){
lighten[tmp.x][tmp.y]=1;
ans++;
// printf("ttt %d %d\n",tmp.x,tmp.y);
}
if(!vis[tmp.x][tmp.y]){
// printf("vis %d %d\n",tmp.x,tmp.y);
if(access(tmp.x,tmp.y)){
vis[tmp.x][tmp.y]=1;
q.push((node){tmp.x,tmp.y});
}
}
}
for(i=0;i<4;i++){
int xx=v.x+d[i][0];
int yy=v.y+d[i][1];
// printf("xxx %d %d %d\n",xx,yy,lighten[xx][yy]);
if(xx<=n&&xx>0&&yy<=n&&yy>0&&!vis[xx][yy]&&lighten[xx][yy]){
vis[xx][yy]=1;
q.push((node){xx,yy});
}
}
}
printf("%d\n",ans);
}
int main()
{
std::ios::sync_with_stdio(false);
int m,a,b,c,d,i;
scanf("%d%d",&n,&m);
for(i=1;i<=m;i++){
scanf("%d %d %d %d",&a,&b,&c,&d);
mp[(a-1)*n+b].push_back((c-1)*n+d);
}
BFS();
return 0;
}I:
简单题
贪心，每次找出一个比他大，但是最小的牌
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
#define ll long long
const int ding=5e5+5;
int a[ding],vis[2*ding],b[ding];
int main()
{
// std::ios::sync_with_stdio(false);
int n,i,ans=0;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d",&a[i]);
vis[a[i]]=1;
}
int cnt=0;
for(i=1;i<=2*n;i++){
if(!vis[i])b[++cnt]=i;
}
sort(a+1,a+n+1);
sort(b+1,b+n+1);
int nn=1;
for(i=1;i<=n;i++){
int tmp=lower_bound(b+nn,b+n+1,a[i])-b;
// printf("%d %d\n",a[i],b[tmp]);
if(tmp!=n+1){
ans++;
nn=tmp+1;
}
else break;
}
printf("%d\n",ans);
return 0;
}J:
首先离散化，因为冒泡排序是稳定的排序所以离散化首先是按照价值，如果价值相同按照出现顺序排序
相当于把当前序列最后排序为1、2、3、4、5、6……n 这样的序列
每一趟的冒泡排序会把 i 前面一个比 i 大的数交换到 i 后面，所以我们找出每个数前面比 i 大的数 然后求一个最大 就是冒泡排序的趟数
用树状数组
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
#define ll long long
const int ding=100005;
int b[ding],a[ding],c[ding];
int n;
struct node{
int id,val;
}init[ding];
int lobit(int x){
return x&(-x);
}
void add(int x){
while(x<=n){
b[x]++;
x+=lobit(x);
}
}
int sum(int x){
int ans=0;
while(x>=1){
ans+=b[x];
x-=lobit(x);
}
return ans;
}
//void lsh(){
// int i;
// sort(c+1,c+1+n);
// int cnt=unique(c+1,c+1+n)-c;
// for(i=1;i<=n;i++){
// a[i]=lower_bound(c+1,c+1+cnt,a[i])-c;
// }
//}
bool cmp(node a,node b){
if(a.val!=b.val)
return a.val<b.val;
return a.id<b.id;
}
int main()
{
std::ios::sync_with_stdio(false);
int i;
int ans=1;
scanf("%d",&n);
for(i=1;i<=n;i++){
// scanf("%d",&a[i]);
scanf("%d",&init[i].val);
init[i].id=i;
// c[i]=a[i];
}
sort(init+1,init+n+1,cmp);
for(i=1;i<=n;i++)
a[init[i].id]=i;
// lsh();
for(i=1;i<=n;i++){
add(a[i]);
ans=max(ans,i-sum(i));
}
printf("%d\n",ans);
return 0;
}K:
暴力枚举每个点的值，最后求一个最小的
每次转移的时候，可以通过上一个转移求得
这样复杂度就是O（n）
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
#define ll long long
int a[1005];
int main()
{
std::ios::sync_with_stdio(false);
int n,tol=0,cnt=0,ans,i;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d",&a[i]);
tol+=a[i];
}
a[0]=a[n];
a[n+1]=a[1];
for(i=2;i<=n;i++){
cnt+=(i-1)*a[i];
}
ans=cnt;
for(i=2;i<=n;i++){
cnt=cnt-(tol-a[i]-a[i-1])-a[i]+(n-1)*a[i-1];
ans=min(ans,cnt);
}
printf("%d\n",ans);
return 0;
}L:
暴力枚举
前缀和O（1）求出每次的最大值
这样复杂度就是O（n^2）
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
#define ll long long
int mp[1005][105],sum[105][105],x[105],y[106],lisx[105],lisy[105];
int main()
{
std::ios::sync_with_stdio(false);
int n,b,ans=0x3f3f3f3f;
int i,mm,m,j,totx=0,toty=0;
scanf("%d %d",&n,&b);
for(i=1;i<=n;i++){
scanf("%d %d",&x[i],&y[i]);
lisx[++totx]=x[i];
lisy[++toty]=y[i];
}
sort(lisx+1,lisx+totx+1);
sort(lisy+1,lisy+toty+1);
totx=unique(lisx+1,lisx+totx+1)-lisx;
toty=unique(lisy+1,lisy+toty+1)-lisy;
for(i=1;i<=n;i++){
x[i]=lower_bound(lisx+1,lisx+totx+1,x[i])-lisx;
y[i]=lower_bound(lisy+1,lisy+toty+1,y[i])-lisy;
mp[x[i]][y[i]]=1;
}
mp[0][0]=0;
for(i=1;i<=n+1;i++){
for(j=1;j<=n+1;j++){
mp[i][j]=mp[i-1][j]+mp[i][j-1]-mp[i-1][j-1]+mp[i][j];
}
}
for(i=2;i<=n+1;i++){
for(j=2;j<=n+1;j++){
int x=mp[i][j],y=mp[n][j]-x,p=mp[i][n]-x,q=n-x-y-p;
int tmp=max(x,max(y,max(p,q)));
ans=min(ans,tmp);
}
}
printf("%d\n",ans);
return 0;
}
扫一扫
215
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
