ACM Steps_Chapter Nine_Section3

最新推荐文章于 2018-11-21 22:47:26 发布
最新推荐文章于 2018-11-21 22:47:26 发布
阅读量442 收藏
点赞数
分类专栏： ACM Steps
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oldoldb/article/details/8915409
版权

Snail’s trouble

#include"stdio.h"
#include"string.h"
#include"stdlib.h"
#include"math.h"
#define N 111
int ans[N];
void init()
{
	ans[5]=272400600;
	ans[6]=9717617;
	ans[7]=898515;
	int k,q;
	double t,temp;
	for(k=8;k<=100;k++)
	{
		t=0;
		temp=1;
		q=0;
		while(t<100)
		{
			t+=k/temp;
			temp++;
			q++;
		}
		ans[k]=q;
	}
}
int main()
{
	init();
	int k;
	while(scanf("%d",&k)!=-1)
		printf("%d\n",ans[k]);
	return 0;
}

Queuing

/*
题意：f代表男，m代表女，给定长度L，有2^L个不同组合的字符串（f、m相间），不能出现fmf和fff，问有几种组合。

思路：只要能找到递推公式就可以马上切掉这题。

设f(n)为字符串长度为n时复合条件的字符串个数，以字符串最后一个字符为分界点，当最后一个字符为m时前n-1个字符没有限制，即为f(n-1)；当最后一个字符为f时就必须去除最后3个字符是fmf和fff的情况,在考虑最后两个字符为mf和ff的情况，显然不行；最后3个字符为fmf、mmf和fff、mff时只有当最后3个字符为mmf时前n-3个字符没有限制，即为f(n-3)，当为mff时第n-3个字符可能为f因而对前n-3个字符串有限制；最后4个字符为fmff和mmff时mmff可行。这样就讨论完了字符串的构成情况，得出结论：
f(n)=f(n-1)+f(n-3)+f(n-4)
然后就像fibonacci那样构建矩阵用快速幂取模。。。
*/
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <string>
 #include <algorithm>
 #include <iostream>
 using namespace std;
 
 int f[5]={0,2,4,6,9};
 typedef struct In{
     int m[5][5];
 }Matrix;
 Matrix init,unit,F;
 int n,m;
 
 void Init(){
     for(int i=1;i<=4;i++){
         for(int j=1;j<=4;j++){
             if(i==1&&j==1) init.m[i][j]=1;
             else if(i==1&&j==3) init.m[i][j]=1;
             else if(i==1&&j==4) init.m[i][j]=1;
             else if(i==2&&j==1) init.m[i][j]=1;
             else if(i==3&&j==2) init.m[i][j]=1;
             else if(i==4&&j==3) init.m[i][j]=1;
             else init.m[i][j]=0;
             unit.m[i][j]=(i==j);
             F.m[i][j]=0;
         }
     }
     F.m[1][1]=f[4];
     F.m[2][1]=f[3];
     F.m[3][1]=f[2];
     F.m[4][1]=f[1];
 }
 
 Matrix Mul(Matrix a,Matrix b){
     Matrix c;
     for(int i=1;i<=4;i++)
         for(int j=1;j<=4;j++){
             c.m[i][j]=0;
             for(int k=1;k<=4;k++){
                 c.m[i][j]+=a.m[i][k]*b.m[k][j]%m;
                 c.m[i][j]%=m;
             }
         }
     return c;
 }
 
 Matrix Pow(Matrix a,Matrix b){
     while(n){
         if(n&1) b=Mul(a,b);
         a=Mul(a,a);
         n>>=1;
     }
     return b;
 }
 
 int main(){
     
 //    freopen("data.in","r",stdin);
 //    freopen("data.out","w",stdout);
     
     while(scanf("%d%d",&n,&m)!=EOF){
         if(n<5){
             printf("%d\n",f[n]%m);
             continue;
         }
         Init();
         n-=4;
         Matrix x=Pow(init,unit);
         x=Mul(x,F);
         printf("%d\n",x.m[1][1]%m);
     }
     return 0;
 }

胜利大逃亡(续)

#include<cstdio>
#include<queue>
#include<string.h>
using namespace std;
struct state{
	state(int a,int b,int d,int e){r=a,c=b,v=d,st=e;}
	int r,c,v,st;	
};
char map[30][30];
int n,m,t,stx,sty,mint;
int vis[30][30][1100];
int dr[]={1,0,-1,0},dc[]={0,1,0,-1};

int bfs(){
	memset(vis,0,sizeof vis);
	queue<state> q;
	q.push(state(stx,sty,0,0));
	vis[stx][sty][0]=1;
	
	while(!q.empty()){
		state os=q.front();q.pop();
		int r=os.r,c=os.c,v=os.v,st=os.st;//旧的状态参数
		for(int i=0;i<4;i++){
			int nr=r+dr[i],nc=c+dc[i],nv=v,nst=st+1;//新的状态参数	
			if(nst>=t||nr<0||nc<0||nr>=n||nc>=m||map[nr][nc]=='*')continue;//超出时间，范围，以及墙都是不可达位置
			char tc=map[nr][nc];
			if(tc=='^')return nst;//到达终点
			if(tc>='A'&&tc<='J'){//如果到了这个点却没有对应钥匙
				if((nv&(1<<(tc-'A')))==0)continue;	
			}else if(tc>='a'&&tc<='j'){//如果到的这个点有钥匙
				nv^=(1<<(tc-'a'));
			}
			if(!vis[nr][nc][nv]){//如果这个点未被访问过
				vis[nr][nc][nv]=1;
				q.push(state(nr,nc,nv,nst));	
			}

		}	
	}
	return -1;
}
int main(){
	while(scanf("%d%d%d",&n,&m,&t)!=EOF){
		for(int i=0;i<n;i++){
			scanf("%s",map[i]);	
			for(int j=0;j<m;j++){
				if(map[i][j]=='@')stx=i,sty=j;	
			}
		}
		printf("%d\n",bfs());
	}
	return 0;	
}

The Worm Turns

#include<cstdio>
#include<cstring>
using namespace std;
#define MAX 630
char mat[MAX][MAX];
bool visit[MAX][MAX];
int dir[4][2]= {0,1,-1,0,1,0,0,-1};
int n,m,maxx;
int xi,yi,ki,xt,yt,kt;
void dfs(int a,int b,int d,int step)//深搜
{
    if(step>maxx)//更新最大值
    {
        maxx=step;
        xi=xt;
        yi=yt;
        ki=kt;
    }
    int tx=a+dir[d][0],ty=b+dir[d][1];
    if(tx<0||tx>=n||ty<0||ty>=m||visit[tx][ty]==true||mat[tx][ty])
    {
        if(step==0) return;//第一步是不允许转向的
        for(int i=0; i<4; ++i)
        {
            if(i==d) continue;
            tx=a+dir[i][0];
            ty=b+dir[i][1];
            if(0<=tx&&tx<n&&0<=ty&&ty<m&&visit[tx][ty]==false&&!mat[tx][ty])
            {
                visit[tx][ty]=true;
                dfs(tx,ty,i,step+1);
                visit[tx][ty]=false;
            }
        }
    }
    else
    {
        visit[tx][ty]=true;
        dfs(tx,ty,d,step+1);
        visit[tx][ty]=false;
    }

}
int main()
{
    int t,a,b;
    char c;
    for(int cas=1; ~scanf("%d%d",&n,&m); ++cas)
    {
        if(n+m==0) break;
        memset(mat,0,sizeof(mat));
        maxx=0;
        scanf("%d",&t);
        for(; t--;)
        {
            scanf("%d%d",&a,&b);
            mat[a][b]=1;
        }
        //枚举每个点
        for(int i=0; i<n; ++i)
            for(int j=0; j<m; ++j)
                for(int k=0; k<4; ++k)
                    if(!mat[i][j])
                    {
                        xt=i;
                        yt=j;
                        kt=k;
                        visit[i][j]=true;
                        dfs(i,j,k,0);
                        visit[i][j]=false;
                    }
        if(ki==0) c='E';
        if(ki==1) c='N';
        if(ki==2) c='S';
        if(ki==3) c='W';
        printf("Case %d: %d %d %d %c\n",cas,maxx+1,xi,yi,c);
    }
    return 0;
}

T9

/*
字典树，不难。建字典树时对每一点有一个频度值，
每次取这一层上频度最大的字母所在路径所组成的
*/
#include<cstdio>
#include<string.h>
using namespace std;
struct trie{
	trie(){
		for(int i=0;i<26;i++)next[i]=NULL;
		pro=0;
	}
	trie *next[26];
	int pro;
}*root;
int cas,words,k;
char find[105],res[105],bres[105],wd[105];
int bpro;
bool flag;
//对应按键上的字母
int alpha[8][5]={{0,1,2},{3,4,5},{6,7,8},{9,10,11},{12,13,14},{15,16,17,18},{19,20,21},{22,23,24,25}};
int alphas[8]={3,3,3,3,3,4,3,4};
void instrie(char *wd,int pro){
	int len=strlen(wd);
	trie *p=root;
	for(int i=0;i<len;i++){
		int t=wd[i]-'a';
		if(p->next[t]==NULL){
			p->next[t]=new trie;	
		}
		p=p->next[t];
		p->pro+=pro;//字典树上每一点的概率
	}
}
void dfs(int now,int len,trie *tr){
	if(now==len){//标记字典中右对应按键的结果并且选择最大概率的组合
		flag=true;
		if(tr->pro>bpro){
			bpro=tr->pro;	
			for(int i=0;i<now;i++){
				bres[i]=res[i];	
			}
			bres[now]='\0';
		}
		return;
	}
	int t=find[now]-'2';
	for(int i=0;i<alphas[t];i++){
		int r=alpha[t][i];
		if(tr->next[r]==NULL)continue;
		res[now]=r+'a';
		dfs(now+1,len,tr->next[r]);		
	}
	
}

int main(){
	int pro;
	scanf("%d",&cas);
	for(int ca=1;ca<=cas;ca++){
		printf("Scenario #%d:\n",ca);
		scanf("%d",&words);
		root=new trie;
		for(int i=0;i<words;i++){
			scanf("%s%d",wd,&pro);
			instrie(wd,pro);
		}
		scanf("%d",&k);
		while(k--){
			scanf("%s",find);
			int len=strlen(find);
			for(int i=1;i<len;i++){
				flag=false;
				bpro=0;
				dfs(0,i,root);
				if(flag){
					printf("%s\n",bres);
				}else{
					printf("MANUALLY\n");
				}
			}
			printf("\n");
		}
		printf("\n");
	}
	return 0;	
}

Cycling

#include<cstdio>
#include<cmath>
#include<algorithm>
#include<string.h>
#include<queue>
//枚举上下界求最短路
using namespace std;
const int inf=1000000000;
struct node{
    int v,i;
    node(int a,int b){v=a,i=b;}
    bool operator <(const node& n)const{
        return v>n.v;
    }    
};
struct ati{
    int l,h;
    bool operator<(const ati& a)const{
        return h-l<(a.h-a.l);    
    }    
}at[100004];
int cas,n,m,h[105],a,b,c;
int map[105][105];
int dij(int low,int high){
    int done[105];
    int d[105];
    for(int i=1;i<=n;i++)d[i]=inf;
    d[1]=0;
    memset(done,0,sizeof done);
    priority_queue<node> pq;
    pq.push(node(d[1],1));
    
    while(!pq.empty()){
        node nd=pq.top();pq.pop();
        int u=nd.i;
        if(done[u]||h[u]<low||h[u]>high)continue;
        done[u]=1;
        for(int v=1;v<=n;v++){
            if(h[v]<low||h[v]>high)continue;
            if(map[u][v]&&d[v]>d[u]+map[u][v]){
                d[v]=d[u]+map[u][v];
                pq.push(node(d[v],v));    
            }
        }
    }
    return d[n];
}
int myabs(int x){return x>0?x:-x;}
int main(){
    int cas;
    scanf("%d",&cas);
    while(cas--){
        memset(map,0,sizeof map);
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)scanf("%d",&h[i]);
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&a,&b,&c);
            if(map[a][b]&&map[a][b]<c)continue;
            map[a][b]=map[b][a]=c;    
        }
        
        int k=0;
        int lmin=min(h[1],h[n]),lmax=max(h[1],h[n]);
        for(int i=1;i<=n;i++){
            for(int j=i;j<=n;j++){
				if(min(h[i],h[j])>lmin||max(h[i],h[j])<lmax)continue;
                at[k].l=min(h[i],h[j]);
                at[k++].h=max(h[i],h[j]);
            }    
        }
        sort(at,at+k);
        for(int i=0;i<k;i++){
            int d=dij(at[i].l,at[i].h);
            if(d!=inf){
                printf("%d %d\n",at[i].h-at[i].l,d);
                break;        
            }    
        }
    }
    return 0;    
}

Game

/*
能从A取一部分到B，当B<A,并且（A+B）%2=1，（A+B）%3=0，其中A，B是堆的编号

博弈，搞不来啊。将堆数分成两部分，一部分到终态要奇数步，一部分要偶数步。对奇数步的做NIM
*/
#include<cstdio>
using namespace std;
int cas,n,a;
//1,3,4是最终状态，%6为0，2，5为奇数步，对这些堆做NIM游戏
int main(){
	scanf("%d",&cas);
	for(int ca=1;ca<=cas;ca++){
		int rs=0;
		scanf("%d",&n);
		for(int i=1;i<=n;i++){
			scanf("%d",&a);
			if(i%6==0||i%6==2||i%6==5)rs^=a;
		}	
		printf("Case %d: ",ca);
		printf(rs?"Alice\n":"Bob\n");
	}
	return 0;	
}

Equations

/*
简单的哈希，但是要注意在a,b,c,d都是正或者都是负的情况要直接排除，否则会TLE
*/
#include<cstdio>
#include<string.h>
using namespace std;
int hash[2000005];
int main(){
	int a,b,c,d;
	while(scanf("%d%d%d%d",&a,&b,&c,&d)!=EOF){
		//注意排除
		if((a>0&&b>0&&c>0&&d>0)||(a<0&&b<0&&c<0&&d<0)){
			printf("0\n");
			continue;	
		}		
		memset(hash,0,sizeof hash);
		for(int i=-100;i<=100;i++){
			for(int j=-100;j<=100;j++){
				if(i&&j)hash[a*i*i+b*j*j+1000000]++;	
			}	
		}
		int rs=0;
		for(int i=-100;i<=100;i++){
			for(int j=-100;j<=100;j++){
				if(i&&j)rs+=hash[-c*i*i-d*j*j+1000000];	
			}	
		}
		printf("%d\n",rs);
	}
	
}


屎宝宝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU OJ ACM Steps 上的题目详细介绍
悠然见南山的博客
11-19 1323
之前在杭电 OJ 上做题，看到有 ACM Steps 这个链接，进去之后发现是一个类似于闯关的机制，可以让增加做题人的激情……据说完全通关后会有奖励，不知道是不是真的。但是里面没有题目的分类介绍，每一关只给出了题目，并没有给出相关的知识点介绍，是我太菜的缘故吧，想想大神们看了题不就能知道了吗……，但是只有做出来本关的题目后，才能查看下一关的题目，所以我到网上搜了搜看看有没有详细的介绍，结果发现有一个
《高效的项目和团队》
海阔天空 邵加超的BLOG
01-04 1万+
Productive Projects and Teams是一本好书。 许多其中许多关于管理和沟通的精辟言论让我大有相见很晚之感。其实不仅是软件的开发项目，任何项目，甚至任何行业的管理，都首先是对人的管理，然后才是对事物的管理，所以设身处地的为别人着想，用鼓励来代替批评，用相互学习来取消互相排挤，在失败中学习，在前进中自醒，则无往而不胜。鉴于原书是英文的，我打算利用业余时间把它翻译成中文，一来方便
ACM Steps_Chapter Nine_Section1
VeryBigMan
05-09 571
A == B ? /* 测试数据： 0 -0 0 +0 123.123 +00123.12300 100.00 100 .1 0.1 000.000 0 123456789123456789 12345
ACM Steps_Chapter Nine_Section2
VeryBigMan
05-09 500
Picture #include #include #include #include using namespace std; int main() { int n,m; while(scanf("%d%d",&n,&m)!=EOF) { cout<<"+"; for(int i=0;i<n;++i) {
学习笔记---程序员练级攻略（入门篇、修养篇、专业基础篇、软件设计篇、高手成长篇）
热门推荐
shuifa2008的专栏
11-21 2万+
根据极客时间 左耳朵耗子 整理，请忽略最后的每一行最后的数字 入门篇 47 1.1. 零基础启蒙 47 1.1.1. 十年学会编程：http://norvig.com/21-days.html 47 1.1.2. 程序员的谎谬之言还是至理名言？：https://coolshell.cn/articles/4235.html 47 1.1.3. 《与孩子一起学编程》 47 1.1.4. 在线编程...
Technical Report
yangjia_cheng的博客
04-06 2465
Technical ReportNumber 574Computer LaboratoryUCAM-CL-TR-574ISSN 1476-2986Sketchpad: A man-machine graphicalcommunication systemIvan Edward SutherlandSeptember 2003New preface by Alan Blackwell andKerr...
HSL and HSV
计算机视觉算法、工程、产品
10-03 2784
HSL and HSV https://en.wikipedia.org/wiki/HSL_and_HSV#From_HSV From Wikipedia, the free encyclopedia Contents   [hide]  1Basic principle2Motivation3Formal derivation
How to Succeed in Graduate School: A Guide for Students and Advisors-1
09-28 918
Abstract This paper attempts to raise some issues that are importantfor graduate students to be successful and to get as muchout of the process as possible, and for advisors wh...
RSA Algorithm
凌风探梅的专栏
08-12 3723
The RSA algorithm is named after Ron Rivest, Adi Shamir and Len Adleman, who invented it in 1977[RIVE78]. The basic technique was first discovered in 1973 by Clifford Cocks [COCK73]of CESG (part of the British GCHQ) but this was a secret until 1997.The pat
ACM.rar_ACM编程_acm solutions_浙大acm
最新发布
09-24
这个压缩包的名字“ACM编程_acm solutions_浙大acm”暗示了其内容主要是关于ACM竞赛的编程解决方案，特别提到了浙江大学的ACM团队，这可能意味着这些解决方案或题解来源于或至少是针对浙江大学ACM竞赛训练的。...
ACM.rar_ACM_ACM PDF_ACM pdf
09-14
《ACM算法详解与实战指南》 ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest，简称ICPC或ACM）是一项极具挑战性的全球性赛事，旨在培养大学生的编程能力、逻辑思维以及团队协作精神。...
ACM.rar_acm final_visual c
09-23
3. **算法和数据结构**：在ACM竞赛中，掌握各种算法和数据结构至关重要，比如排序、搜索、图论、动态规划等。选手需要快速理解和实现这些问题的解决方案。 4. **编程技巧**：高效编程技巧，如代码优化、错误处理、...
acm.rar_1048_ACM_acm 答案_visual c
09-21
3. Cpp1915.cpp：ACM题目1915的C++实现。 4. 1048.cpp：显然，这是针对题目1048的C++代码。 5. 1115.cpp：对应ACM题目1115的解答。 6. Cpp2201.cpp：ACM题目2201的C++解法。 7. www.pudn.com.txt：这个看起来像是一...
acm.rar_ACM java_java package acm
09-23
在Java编程领域，ACM（Association for Computing Machinery）常常与算法竞赛相关，因为ACM国际大学生程序设计竞赛（ICPC）广泛使用Java作为比赛语言之一。"acm.jar" 文件通常包含了一些为这类竞赛设计的预封装的...
ACM Steps_Chapter Six_Section3
VeryBigMan
05-07 979
Strategic Game /* 做该题要掌握以下两点： 1、二分图最小顶点覆盖 = 双向二分图最大匹配 / 2 。 2、利用STL中的vector的可以很方便的建立图的邻接表存储。主要用到push_back()、clear()操作。 3、scanf()和printf()函数可以很方便的实现题中的输入和输出。详见代码。 */ #include #include using namespa
ACM Steps_Chapter Two_Section1
VeryBigMan
04-21 600
最小公倍数 #include #include using namespace std; int gcd(int a,int b) { int r; if(a<b) swap(a,b); r=a%b; while(r) { a=b; b=r; r=a%b; } return b; } int lcm(int a,int b) { return a*b/gc
ACM Steps_Chapter Four_Section3
VeryBigMan
05-02 570
Tempter of the Bone /* 题意：这个题目的意思是给定你起点S，和终点D，问你是否能在 T 时刻恰好到达终点D。 分析：这样一看很明显是DFS，不过里面涉及到很多剪枝。 奇偶剪枝： 是数据结构的搜索中，剪枝的一种特殊小技巧。 现假设起点为(sx,sy)，终点为（ex,ey），给定t步恰好走到终点， 　 s | | |
ACM Steps_Chapter Seven_Section2
VeryBigMan
05-07 562
The Euler function /* 定义： 对于正整数n，φ(n)是小于或等于n的正整数中，与n互质的数的数目； 例如: φ(8) = 4, 因为1，3，5，7均和8互质。 性质： 1. 若p是质数，φ（p）= p-1. 2. 若n是质数p的k次幂，φ（n）= （p-1）p^(k-1)

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值