2錛屽鏋滃壀鏋濓紝
鏍規嵁鍥炴函鐨勮繃紼嬶紝浼氬厛姹傚埌dfs(n)鏈鍚庨偅涓粨鐐癸紝鍐嶆槸dfs(n-1)..dfs(1)銆?br>鍓灊搴斿綋鏄湪緇撴瀯浣撲腑N[i]澧炲姞涓涓彉閲?/span>vnow,
vnow鍒濆間負0錛岃褰曚粠璇ョ粨鐐瑰紑濮嬫悳绱㈡墍鏈?/span>int dfs(i)鐨勮繑鍥炲鹼紝騫朵笉鏂洿鏂頒嬌鍏舵渶澶э紝
褰撴悳绱㈠埌i鐨勬椂鍊欙紝濡傛灉N[i].vnow涓嶄負0錛屽垯闇瑕佹弧瓚?/span>N[i].vnow+褰撳墠temp錛堝墠闈㈢殑鍙緋誨垪鐨勬誨鹼級>vmax(鎵瑕佹眰鐨勬渶澶у肩殑褰撳墠鍊?/span>)錛岃嫢vnow涓?/span>0錛屽垯鍙互涓嶆弧瓚寵繖涓潯浠訛紝鍥犱負榪欐槸絎竴嬈°?/span>
]]>
into each circle separately, and the sum of numbers in two adjacent circles should be a prime.
Note: the number of first circle should always be 1.
Input
n (0 < n <= 16)Output
The output format is shown as sample below. Each row represents a series of circle numbers in the ring beginning from 1 clockwisely and anticlockwisely. The order of numbers must satisfy the above requirements.
You are to write a program that completes above process.
Sample Input
6 8
Sample Output
Case 1: 1 4 3 2 5 6 1 6 5 2 3 4 Case 2: 1 2 3 8 5 6 7 4 1 2 5 8 3 4 7 6 1 4 7 6 5 8 3 2 1 6 7 4 3 8 5 2
寰堢粡鍏哥殑娣辨悳錛屽惎鍙?br>1錛岄澶勭悊闈炲父閲嶈錛?br>錛?錛夛紝鍏堟眰鍑烘墍鏈夌殑prime鏁版渶澶?16+16錛宐ool isprime[32],
錛?錛夌敱浜庡凡緇忕粰鍑鴻寖鍥達紝鎴戜滑鍙互鍏堟眰鍑?-19鐨勬瘡涓暟涓嬩竴涓彲鑳界殑鍙栧鹼紝渚嬪15錛屼笅涓涓彲浠ュ彇2,4,------涓ら噸for寰幆錛屽彲浠ラ伩鍏嶆悳绱㈡椂閲嶅鍒ゆ柇銆?br>2錛岀敤涓涓暟緇勮褰曚嬌杈撳嚭鐨勬湁搴忥紝op[n]涓巇fs(int begin,int n)涓璶瀵瑰簲
if( bp[t] )
{
op[o] = t ;
o ++ ;
bp[t] = false ;
dfs( t , n );//
o -- ;
bp[t] = true ;
}
]]>
Io and Ao are playing a word game. They say a word in the dictionary by turns. The word in the dictionary only contains lowercase letters. And the end character of the former said word should be the same as the start character of the current said word. They can start the game from any word in the dictionary. Any word shouldn't be said twice. Now, we define the complexity of the game that is the sum length of all words said in the game. Give you a dictionary, can you tell me the max complexity of this word game?
Input
The first line contains a single positive integer n(0 < n <=12). Next n lines are n words in the dictionary. The length of each word will not exceed 100.
Output
A single integer represents the complexity of the game.
Sample Input
3 joj jlu acm 6 cctv redcode lindong we love programming 3 daoyuanlee come on
Sample Output
6 11 10
Problem Source: provided by loon
#include<iostream>
#include<cstdlib>
using namespace std;
struct S
{
string a;
char begin;
char end;
int length;
}s[13];
int visited[13];
int temp;
void search(int a,int num,int pre)
{
for(int i=0;i<num;i++ )
{
if(s[i].begin==s[pre].end&&visited[i]==0)
{
visited[i]=1;
search(a+s[i].length,num,i);
if(a+s[i].length>temp)temp=a+s[i].length;
visited[i]=0;
}
}
}
int main()
{
freopen("s.txt","r",stdin);
freopen("key.txt","w",stdout);
int num;
while(cin>>num)
{
int i;
temp=0;
for( i=0;i<num;i++)
{
cin>>s[i].a;
s[i].length=(s[i].a).size();
s[i].begin=(s[i].a)[0];
s[i].end=(s[i].a)[s[i].length-1];
if(s[i].length>temp)
temp=s[i].length;
}
for(i=0;i<num;i++)
{
memset(visited,0,sizeof(visited));
visited[i]=1;
search(s[i].length,num,i);
}
cout<<temp<<endl;
}
//system("PAUSE");
return 0;
}
浠ヤ笂浠ｇ爜瓚呮椂銆傚畬鍏ㄥ彲浠ュ壀鏋濄?br>涓句釜渚嬪瓙
abc
cbd
dbm
dbacmdp
鎴戠殑紼嬪簭涓鐩存悳鍟婃悳錛屾瘡嬈℃悳瀹岄兘閲嶆柊寮濮嬨傛瘮濡傚湪浠寮澶村悗錛屾悳鍒癱錛屼笅嬈″啀鎼滅儲鏃剁洿鎺ュ埄鐢╟鐨勭粨鏋滐紝榪欐槸娣辨悳鐨勭壒鐐瑰喅瀹氱殑錛侊紒錛?br>*************************
榪欑綾諱技鐨勬湁搴忔悳绱㈤兘鍙互鐢?nbsp; * 澶囧繕褰曟柟娉?
**************************
#include<iostream>
#include<cstdlib>
using namespace std;
int num;
struct S
{
string a;
char begin;
char end;
int length;
}s[13];
int visited[13];
int temp;
int sum[13];
int search(int pre)//·µ»Ø´ÓpreµãÒÔºóµÄ×ܵÄÖµ
{
int j=s[pre].length,k=0;
for(int i=0;i<num;i++ )
{
if(s[i].begin==s[pre].end&&visited[i]==0&&i!=pre)//蹇呴』瑕佹湁I錛?pre
{
visited[i]=1;
k=search(i)+s[pre].length;
if(k>j)j=k;
}
else
{
if(s[i].begin==s[pre].end&&i!=pre)//蹇呴』瑕佹湁i!=pre
return sum[i]+s[pre].length;//鐩稿綋浜庡蹇樺綍錛岃屼笖鏃犻渶visited[i]=0;
}
}
sum[pre]=j;
return j;
}
int main()
{
freopen("s.txt","r",stdin);
freopen("key.txt","w",stdout);
while(cin>>num)
{
int i,j;
temp=0;
j=0;
for( i=0;i<num;i++)
{
cin>>s[i].a;
s[i].length=(s[i].a).size();
s[i].begin=(s[i].a)[0];
s[i].end=(s[i].a)[s[i].length-1];
if(s[i].length>temp)
temp=s[i].length;
}
for(i=0;i<num;i++)
{
memset(visited,0,sizeof(visited));
memset(sum,0,sizeof(sum));
visited[i]=1;
j=search(i);
if(j>temp)
temp=j;
}
cout<<temp<<endl;
}
//system("PAUSE");
return 0;
}
鍥犱負I錛?pre鍙堥敊浜嗗嚑涓嬨?br>浠ュ悗debug灝介噺鑷繁鐢ㄧ溂鐫涚湅錛屾洿鐪佹椂闂達紒錛侊紒錛侊紒錛侊紒錛侊紒
]]>
Output
For each test case you have to find the length of the longest path that begins at the starting place. You also have to print the number of the final place of such longest path. If there are several paths of maximum length, print the final place with smallest number.Print a new line after each test case.
Sample Input
2 1 1 2 0 0 5 3 1 2 3 5 3 1 2 4 4 5 0 0 5 5 5 1 5 2 5 3 5 4 4 1 4 2 0 0 0
Sample Output
Case 1: The longest path from 1 has length 1, finishing at 2. Case 2: The longest path from 3 has length 4, finishing at 5. Case 3: The longest path from 5 has length 2, finishing at 1.
鎻愪氦浜?0嬈★紝AC 3嬈★紝瓚呮椂4嬈★紝wa 3嬈°?/pre>寰堟棤璇?/pre>搴旇鏄姩鎬佽鍒掓渶濂斤紝浣嗘槸鎴戜笉鏄緢鐔燂紝鐢ㄤ簡鎼滅儲銆備互涓嬫槸瓚呮椂鐨勪唬鐮?/pre>#include<iostream> #include<cstdlib> using namespace std; int path[101][101]; int mark[101]; int len[101];// int end[101]; int dfs(int start,int num)//榪斿洖浠庡綋鍓嶇偣鍑哄彂鐨勬渶澶ч暱搴? { if(mark[start]==1)return len[start]; mark[start]=1; end[start]=start; for(int i=1;i<=num;i++) { if(path[start][i]) { if(len[start]<dfs(i,num)+1) { len[start]=len[i]+1; end[start]=end[i]; } else if(len[start]==len[i]+1&&end[start]>end[i]) end[start]=end[i]; } } mark[start]=0;//榪欏彞鍧氬喅涓嶉渶瑕? return len[start]; } int main() { // freopen("s.txt","r",stdin); //freopen("key.txt","w",stdout); int j,k,turn=0; int start,num; while(cin>>num) { turn++; if(num==0)break; memset(path,0,sizeof(path)); memset(mark,0,sizeof(mark)); memset(len,0,sizeof(len)); memset(end,0,sizeof(end)); cin>>start; while(cin>>j>>k) { if(j==0)break; path[j][k]=1; } cout<<"Case "<<turn<<": The longest path from "<<start<<" has length "<<dfs(start,num)<<", finishing at "<<end[start]<<"."<<endl<<endl; } //system("PAUSE"); return 0; }浠ヤ笅鏄痑c鐨勪唬鐮?/pre>#include<iostream> #include<cstdlib> using namespace std; int path[102][102]; int mark[102], len[102],end[102]; int dfs(int start,int num)//榪斿洖浠庡綋鍓嶇偣鍑哄彂鐨勬渶澶ч暱搴? { if(mark[start]==1)return len[start]; mark[start]=1; end[start]=start; len[start]=0; int i,t; for( i=1;i<=num;i++) { if(path[start][i]) { t=dfs(i,num)+1; if(t>len[start]) { len[start]=t; end[start]=end[i]; } else if(len[start]==t) { if(end[start]>end[i]) end[start]=end[i]; } } } return len[start]; } int main() { //freopen("s.txt","r",stdin); //freopen("key.txt","w",stdout); int j,k,turn=0; int start,num; while(cin>>num,num) { turn++; memset(path,0,sizeof(path)); memset(mark,0,sizeof(mark)); memset(len,0,sizeof(len)); memset(end,0,sizeof(end)); cin>>start; while(cin>>j>>k,j||k) { path[j][k]=1; } dfs(start,num); cout<<"Case "<<turn<<": The longest path from "<<start<<" has length "<<len[start]<<", finishing at "<<end[start]<<"."<<endl<<endl; } //system("PAUSE"); return 0; }涓嶅Θ鎵ц涓涓?/pre>5 3 1 2 3 5 3 1 2 4 4 5 0 0 鍏堟槸len[3]=0;end[3]=3;flag[3]=1;鍐嶆墽琛宼=dfs(1)+1,杞叆dfs錛?錛夛紱len[1]=0;end[1]=1;flag[1]=1;鍐嶆墽琛?span style="COLOR: #0000ff">t=dfs(2)+1;杞叆dfs(2),len[2]=0;end[2]=2;flag[2]=1;鍐嶆墽琛宼=dfs(4)+1
杞叆dfs(4),len[4]=0;end[4]=4;flag[4]=1;鍐嶈漿鍏?span style="COLOR: red">t=dfs錛?)+1;
杞叆dfs(5),len[5]=0;end[5]=5;flag[5]=1;return(len[5]=0);鍒檛=1;t>len[4];len[4]=1;end[4]=end[5]=5;鍐嶇湅4娌′簡鍏朵粬鐩擱偦鍏冪礌銆俤fs(4)=return(len[4])=1;t=dfs(4)+1=2;len[2]=t=2;end[2]=end[4]=5;鍐嶇湅2娌′簡鍏朵粬鐩擱偦鍏冪礌錛宒fs(2)=return(len(2)=2;
鍐嶇湅t=dfs(2)+1=3;len[1]=t=3;end[1]=en[2]=5;鍐嶇湅1鏈夋病鏈夊叾浠栫浉閭誨厓绱狅紝dfs(1)=return(len(1)=3
鍐嶆墽琛宼=dfs(1)+1,len[3]=4;end[3]=end[1]=5;鍐嶇湅3鏈夋病鏈夊叾浠栫浉閭誨厓绱狅紝鏈塪fs(5),宸茬粡閬嶅巻鍒頒簡錛屾墍浠fs錛?錛塺eturn len銆?銆戙?br>娌℃湁褰卞搷銆?br>鍋囪鏀逛負
5 3 5 2 3 5 3 1 2 4 4 1 0 0 鎵ц鏃朵細璧?->1>榪欐椂鐨?緇撶偣len[1]宸茬粡姹傜殑 3>5>2>4>1len[1]宸茬煡浜?/span>
]]>
using namespace std;
int path[6][6];
int row,col,v,h;
bool OK(int i,int j)
{
if(i>=0 && i<row && j>=0 && j<col)
return true;
return false;
}
void DFS(int i,int j,int & counts)
{
if(path[i][j]==1)
{
if(i==v && j==h)
counts++;
return ;
}
path[i][j]=1;
if(OK(i-2,j-1))
DFS(i-2,j-1,counts);
if(OK(i-2,j+1))
DFS(i-2,j+1,counts);
if(OK(i-1,j-2))
DFS(i-1,j-2,counts);
if(OK(i+1,j-2))
DFS(i+1,j-2,counts);
if(OK(i-1,j+2))
DFS(i-1,j+2,counts);
if(OK(i+1,j+2))
DFS(i+1,j+2,counts);
if(OK(i+2,j-1))
DFS(i+2,j-1,counts);
if(OK(i+2,j+1))
DFS(i+2,j+1,counts);
path[i][j]=0;
}
int main()
{
freopen("s.txt","r",stdin);
freopen("key.txt","w",stdout);
while(cin>>row>>col>>v>>h)
{
memset(path,0,sizeof(path));
int counts=0;
DFS(v,h,counts);
cout<<counts<<endl;
}
return 0;
}
On a chess board sizes of m*n(1<=m<=5,1<=n<=5),given a start position,work out the amount of all the different paths through which the horse could return to the start position.(The position that the horse passed in one path must be different.The horse jumps in a way like "鏃?)
Input
The input consists of several test cases.The size of the chess board m,n(row,column),and the start position v,h(vertical , horizontal) ,separated by a space.The left-up point is (0,0)
Output
the amount of the paths in a single line
Sample Input
5 4 3 1
Sample output
4596
瑙ｆ瀽錛?br>椹蛋鏃ワ紝鍏釜鏂瑰悜錛?br>涓嶅厑璁告煇鏉¤礬寰勪笂閲嶅銆?br>if(path[i][j]==1)
{
if(i==v && j==h)
counts++;
//閲嶅鐨勫鏋滄槸鍑哄彂鐐癸紝榪斿洖鍊?br> return ;//鏃犺鎬庢牱錛屽彧瑕侀噸澶嶅氨榪斿洖
}
]]>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
char a[15][30];
bool b[15][30];
int sx,sy,tx,ty;
int ix[4]={0,0,1,-1};
int iy[4]={1,-1,0,0};
struct Node
{
int x,y;
int days;
};
class cmp
{
public:
bool operator ()(const Node & a, const Node & b)
{
return a.days>b.days; //СµÄÏÈpop()³öÀ´£¬Í¬Àí¿ÉÒÔ¶¨ÒåÓÅÏÈ´óµÄ¶ÓÁÐ
}
};
priority_queue<Node,vector<Node>,cmp> qu;
int bfs()
{
int cx,cy;
int tex,tey;
int steps;
Node node;
node.x=sx,node.y=sy,node.days=0;
while(!qu.empty()) qu.pop();
qu.push(node);
while(!qu.empty())
{
node=qu.top();
qu.pop();
steps=node.days;
cx=node.x;
cy=node.y;
for(int i=0;i<4;i++)
{
tex=cx+ix[i];
tey=cy+iy[i];
if(tex>=0 && tex<15 && tey>=0 && tey<30 && b[tex][tey]==false&& a[tex][tey]!='#')
{
node.x=tex;
node.y=tey;
if(a[tex][tey]=='.')
node.days=steps+1;
else if(a[tex][tey]=='M')
node.days=steps+2;
else if(a[tex][tey]='T')
return steps+1;
b[tex][tey]=true;
qu.push(node);
}
}
}
}
int main()
{
// freopen("s.txt","r",stdin);
//freopen("key.txt","w",stdout);
int ca,i,j;
scanf("%d",&ca);
getchar();
while(ca--)
{
memset(b,0,sizeof(b));
for(i=0;i<15;i++)
{
for(j=0;j<30;j++)
{
scanf("%c",&a[i][j]);
if(a[i][j]=='S')
sx=i,sy=j;
else if(a[i][j]=='T')
tx=i,ty=j;
}
getchar();
}
b[sx][sy]=1;
printf("%d\n",bfs());
}
return 0;
}
鍚彂錛氬畾涔夊彉閲忔椂鏈濂借兘璧嬩簣瀹為檯鐨勬剰涔夛紒錛?br> 濂界殑涔犳儻錛岃嫢鏄叧閿瓧鍙崲涓哄ぇ鍐欏瓧姣嶅彉閲?br> 璋冭瘯涓姝ヤ竴姝ョ殑錛佽偗瀹氭槸鏈夐棶棰樼殑涓姝ユ鏉?
]]>
#include<queue>
#include<math.h>
using namespace std;
const int MAX=10000;
int visited[10000];
int result[10000];
bool isprimer(int npp)
{
for (int q = 2; q <= sqrt(double(npp)); ++q)
{
if (npp % q == 0)
{
return 0;
}
}
return 1;
}
int BFS(int start,int end)
{
queue<int> q;
if (start == end)
return 0;
q.push(start);
visited[start]=1;
result[start]=0;
while(!q.empty())
{
int temp=q.front();
q.pop();
int next,j,k;
int num[3];
for (int i =0;i<4;++i)
{
num[0]=temp%10;
num[1]=(temp%100)/10;
num[2]=(temp%1000)/100;
num[3]=temp/1000;
for(j=0;j<=9;j++)
{
num[i]=j;
next=num[0]+num[1]*10+num[2]*100+num[3]*1000;
if((next>1000&&visited[next]!=1)&&isprimer(next))
{
q.push(next);
result[next]=result[temp]+1;
visited[next]=1;
}
if(next==end)
{
return result[next];
}
}
}
}
return MAX;
}
int main() {
//freopen("s.txt","r",stdin);
//freopen("key.txt","w",stdout);
int n,k,j,m;
cin>>j;
while(j--)
{
memset(visited,0,sizeof(visited));
memset(result,0,sizeof(result));
cin>>n>>k;
m=BFS(n,k);
if(m!=MAX)
cout<<m<<endl;
else
cout<<"Impossible"<<endl;
}
return 0;
}
Description
The ministers of the cabinet were quite upset by the message from the Chief of Security stating that they would all have to change the four-digit room numbers on their offices. 鈥?It is a matter of security to change such things every now and then, to keep the enemy in the dark.
鈥?But look, I have chosen my number 1033 for good reasons. I am the Prime minister, you know!
鈥?I know, so therefore your new number 8179 is also a prime. You will just have to paste four new digits over the four old ones on your office door.
鈥?No, it’s not that simple. Suppose that I change the first digit to an 8, then the number will read 8033 which is not a prime!
鈥?I see, being the prime minister you cannot stand having a non-prime number on your door even for a few seconds.
鈥?Correct! So I must invent a scheme for going from 1033 to 8179 by a path of prime numbers where only one digit is changed from one prime to the next prime.
Now, the minister of finance, who had been eavesdropping, intervened.
鈥?No unnecessary expenditure, please! I happen to know that the price of a digit is one pound.
鈥?Hmm, in that case I need a computer program to minimize the cost. You don't know some very cheap software gurus, do you?
鈥?In fact, I do. You see, there is this programming contest going on... Help the prime minister to find the cheapest prime path between any two given four-digit primes! The first digit must be nonzero, of course. Here is a solution in the case above.
1033The cost of this solution is 6 pounds. Note that the digit 1 which got pasted over in step 2 can not be reused in the last step – a new 1 must be purchased.
1733
3733
3739
3779
8779
8179
Input
One line with a positive number: the number of test cases (at most 100). Then for each test case, one line with two numbers separated by a blank. Both numbers are four-digit primes (without leading zeros).
Output
One line for each case, either with a number stating the minimal cost or containing the word Impossible.
Sample Input
3 1033 8179 1373 8017 1033 1033
Sample Output
6 7 0
浠ｇ爜瀹屽叏鍙互浼樺寲錛屾瘮濡傚畾涔変竴涓粨鏋勪綋鍙互鐪佹帀result鏁扮粍錛?br>鎳掑緱鏀逛簡
鍙戠幇poj姣攋oj鏇存儕蹇冨姩欖勫晩錛佺粡甯竎ompling,緇撴灉鍗婂ぉ鎵嶅嚭鐜幫紒
]]>
using namespace std;
int num[100];
int a,s;
int MAX;
void search(int i,int sum)
{
int j;
if(i==a)//鍒拌揪緇堢偣鐨勫鐞?/span>
{
if(sum*(s-sum)>MAX)
MAX=sum*(s-sum);
}
else
for(j=0;j<2;j++)//鍚勪釜鏀礬
{
//鐞嗚涓婂簲褰撴坊鍔犳潯浠跺垽鏂?/span>
search(i+1,sum+j*num[i-1]);
}
}
int main()
{
int b,c,sum;
while(cin>>a)
{
sum=0;
s=0;
MAX=0;
for(b=0;b<a;b++)
{
cin>>num[b];
s+=num[b];
}
search(0, sum);//浠庤繖閲屽紑濮?/span>
cout<<MAX<<endl;
}
} 榪樻湁涓鐐瑰惎鍙戯紝max涓嶈兘鐢紝鍙互鐢∕AX錛屾棤闇璁板綍
There are multiple test cases, the first line of each test case is a integer n. (2<=n<=20) The next line have n integers (every integer in the range [1,1000]). We can divide these n integers into two parts and get the sum of the integers in these two parts, define them as sumA and sumB. Please calc the max number of sumA*sumB and output it in a single line.
Sample Input
3 5 3 7 2 4 9
Sample Output
56 36
Hint
(5,3),(7) sumA=8 sumB=7 sumA*sumB=56 (5),(3,7) sumA=5 sumB=10 sumA*sumB=50 (3),(5,7) sumA=3 sumB=12 sumA*sumB=36 (),(3,5,7) sumA=0 sumB=15 sumA*sumB=0 The max is 56.
]]>