代不在‘

[kuangbin带你飞]专题一简单搜索（大全）

密码：123456

A - Dungeon Master
B - Catch That Cow
C - Fliptile
D - Find The Multiple
E - Prime Path
F - Shuffle'm Up
G - Pots
H - Oil Deposits
I - 非常可乐
J - Find a way
K - 马走日
L - 海贼王之伟大航路
M - 迷宫问题
N - 鸣人和佐助
O - 红与黑
P - 棋盘问题
Q - 拯救行动
R - Saving Tang Monk
S - Fire Game
T - Fire!
U - Cops and Robbers

A - Dungeon Master

题意：
给你一个三维空间，’.‘表示可以通过，’#'表示不能通过，求从起点’S’到终点’E’的最短路径。

题解：
裸bfs，每次可以往六个方向移动，30 * 30 * 30用dfs会TLE。

AC_Code:

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int maxn = 35;
char a[maxn][maxn][maxn];
bool vis[maxn][maxn][maxn];
int step[maxn][maxn][maxn];
int num = 0;
int n,m,h;
int startX, startY, startZ, endX, endY, endZ;
const int Move[6][3] = {{0,0,1},{0,0,-1},{0,1,0},{0,-1,0},{1,0,0},{-1,0,0}};
int minn;

struct node{
	int x,y,z;//高，行，列
	int step;
};

queue<node>q;
node st;
node End;

void init(){
	while(!q.empty()) q.pop();
	memset(vis,false,sizeof(vis));
	st.x = 0; st.y = 0; st.z = 0; st.step = 0;
	End.x = 0; End.y = 0; End.z = 0; End.step = 0;
}

inline bool check(int x, int y, int z){
	if ((x >= 0) && (x < h) && (y >= 0) && (y < n) && (z >= 0) && (z < m) && (!vis[x][y][z]) && (a[x][y][z] == '.' || a[x][y][z] == 'E'))
		return true;
	else
		return false;
}

void bfs(){
	node cur;
	q.push(st);
	while(!q.empty()){
		cur = q.front();
		q.pop();
		if(cur.x == End.x && cur.y == End.y && cur.z == End.z){
			printf("Escaped in %d minute(s).\n",cur.step);
			return;
		}
		vis[cur.x][cur.y][cur.z] = true;
		for(int i=0; i<6; ++i){
			node new_cur;
			new_cur.x = cur.x + Move[i][0];
			new_cur.y = cur.y + Move[i][1];
			new_cur.z = cur.z + Move[i][2];
			if(check(new_cur.x, new_cur.y, new_cur.z)){
				new_cur.step = cur.step + 1;
				q.push(new_cur);
				vis[new_cur.x][new_cur.y][new_cur.z] = true;
			}
		}
	}
	printf("Trapped!\n");
}


int main(){
	while(~scanf("%d%d%d",&h,&n,&m)){//高，行，列
		if(n == 0 && m == 0 && h == 0) break;
		init();
		for(int z=0; z<h; ++z){
			getchar();
			for(int i=0; i<n; ++i){
				for(int j=0; j<m; ++j){
					scanf("%c",&a[z][i][j]);
					if(a[z][i][j] == 'S'){
						st.x = z;
						st.y = i;
						st.z = j;
						st.step = 0;
					}
					if(a[z][i][j] == 'E'){
						End.x = z;
						End.y = i;
						End.z = j;
					}
				}
				getchar();
			}
		}
		bfs();
	}
}

B - Catch That Cow

题意：
在数轴上定一个起点和终点，每一次可以从点X运动到X+1或者X-1或者2*X，问从起点到终点最少需要的步数。（PS：X不能运动到X<0或者X>100000）

题解：
裸bfs。

//
//Write by Yuan Xilan on 2019...
//
#include 
#include 
#include 
#include 
#include 
using namespace std;

const int maxn = 3e5+10;
int n,k;
struct node{
	int x;
	int step;
};
node a;
queue<node>q;
bool vis[maxn];
int minn;

void init(){
	while(!q.empty()) q.pop();
	a.x = n; a.step = 0;
	memset(vis,false,sizeof(vis));
	minn = 0x3f3f3f3f;
}

bool judge(int x){
	if(x >= 0 && x <= 100000) return true;
	return false;
}

void bfs(){
	q.push(a);
	while(!q.empty()){
		node m = q.front();
		q.pop();
		vis[m.x] = true;
		if(m.x == k){
			printf("%d\n",m.step);
			return;
		}
		
		node y;
		y.x = m.x + 1;
		if(!vis[y.x] && judge(y.x)){
			y.step = m.step + 1;
			q.push(y);
			vis[y.x] = true;
		}

		y.x = m.x - 1;
		if(!vis[y.x] && judge(y.x)){
			y.step = m.step + 1;
			q.push(y);
			vis[y.x] = true;
		}

		y.x = m.x * 2;
		if(!vis[y.x] && judge(y.x)){
			y.step = m.step + 1;
			q.push(y);
			vis[y.x] = true;
		}
	}
}

int main(){
	while(~scanf("%d%d",&n,&k)){
		init();
		bfs();
	}
}

C - Fliptile

题意：
有M行N列盏灯，状态为1表示开灯，状态为0表示关灯，每次可对坐标为(x,y)的灯进行一次操作，那么(x-1,y),(x+1,y),(x,y-1),(x,y+1),(x,y)这五盏灯在状态为1时会变为0，在状态为0时，问最少的操作次数，使得最终所有灯的状态均为0，如果不存在输出"IMPOSSIBLE"。

题解：
当第一行的灯的状态确定后，第2到M行灯是否操作都已经确定，举个例子，如果第一行的灯状态为0 1 1 0，第二行的灯状态为1 1 0 1，那么，为了使第一行的第二个灯状态变为0，需要对第二行第二列的灯进行一次操作，为了使第一行的第三个灯状态变为0，需要对第二行第三列的灯进行一次操作，由于上一行的灯的状态只受(i+1,j)灯泡的影响，所以，结论正确。

因此，我们只要枚举所有第一行所有操作的情况，然后判断最后一行是否全为0即可。（因为我们第二行的操作是成全第一行全为0，第三行的操作是成全第二行全为0，…，最后一行的操作是成全倒数第二行全为0）

每个灯的状态有0和1两种，那么m个灯的状态就是2^m个情况，所以我们在枚举时可以结合二进制一起考虑，也就是1<

AC_Code:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
int n,m;

bool vis[205][205];
char s[205][205];
char a[205][205];
char b[205][205];
char c[205][205];
const int Move[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};

void filp(int i, int j){
	if(i > 0) b[i-1][j] = (b[i-1][j] == '0' ? '1' : '0');
	if(j > 0) b[i][j-1] = (b[i][j-1] == '0' ? '1' : '0');
	if(i + 1 < n) b[i+1][j] = (b[i+1][j] == '0' ? '1' : '0');
	if(j + 1 < m) b[i][j+1] = (b[i][j+1] == '0' ? '1' : '0');
	b[i][j] = (b[i][j] == '0' ? '1' : '0');
}

int main(){
	while(~scanf("%d%d",&n,&m)){
		for(int i=0; i<n; ++i){
			for(int j=0; j<m; ++j){
				getchar();
				scanf("%c",&a[i][j]);
			}
		}
		int minn = 0x3f3f3f3f;
		for(int i=0; i<(1<<m); ++i){
			memset(c,0,sizeof(c));
			memcpy(b,a,sizeof(b));
			int cnt = 0;
			for(int j=m-1; j>=0; --j){
				if((i>>(m-1-j)&1) == 1){
					c[0][j] = '1';
					filp(0,j);
					cnt += 1;
				}
				else{
					c[0][j] = '0';
				}
			}

			for(int ii=1; ii<n; ++ii){
				for(int jj=0; jj<m; ++jj){
					if(b[ii-1][jj] == '1'){
						filp(ii,jj);
						c[ii][jj] = '1';
						cnt += 1;
					}
					else c[ii][jj] = '0';
				}
			}

			bool flag = true;
			for(int kk=0; kk<m; ++kk){
				if(b[n-1][kk] == '1'){
					flag = false;
					break;
				}
			}
			if(!flag) continue;
			if(cnt < minn){
				minn = cnt;
				memcpy(s,c,sizeof(s));
			}
		}
		if(minn == 0x3f3f3f3f) cout << "IMPOSSIBLE\n";
		else{
			for(int i=0; i<n; ++i){
				for(int j=0; j<m; ++j){
					if(j != m-1)
						cout << s[i][j] << " ";
					else cout<< s[i][j] << endl;
				}
			}
		}
	}
}

D - Find The Multiple

题意：
给定一个正整数n，请编写一个程序来寻找n的一个非零的倍数m，这个m应当在十进制表示时每一位上只包含0或者1。

题解：
这道题一开始以为位数会很大，然后看到别人开了long long就过了…由于输出任意一个满足即可，从1开始跑bfs即可。

AC_Code:

//
//Write by Yuan Xilan on 2019...
//
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long ll,LL;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
void R() {}
#ifdef HOME
 #define DEBUG(...) {printf("# ");printf(__VA_ARGS__);puts("");}
#else
 #define DEBUG(...)
#endif
const int maxn = 1555510;
ll a[maxn],b[maxn];
int mod = 1e9+7;
ll n;
struct node{
	ll s;	
};
node c;

queue<node>q;

void bfs(){
	q.push(c);
	node d;
	while(!q.empty()){
		d = q.front();
		if(d.s % n == 0){
			cout << d.s << endl;
			return;
		}
		q.pop();
		node e = d;
		e.s = d.s * 10;
		q.push(e);
		e.s = d.s * 10 + 1;
		q.push(e);
	}
}

int main(){
	while(~scanf("%lld",&n) && n){
		c.s = 1LL;
		while(!q.empty()) q.pop();
		bfs();	
	}
}

E - Prime Path

题意：
给你两个四位的素数a，b。a可以改变某一位上的数字变成c，但只有当c也是四位的素数时才能进行这种改变。询问计算a最少经过多少次上述变换才能变成b。

题解：
这道题做得还是挺坎坷的，先将1000到10000的素数先打表，可O(1)判断素数，接下来对每一位进行bfs即可。

AC_Code:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
 
struct node{
	char s[10];
	int step;
};
node a,b;
queue<node>q;
int minn;
bool v[10005];
int m[10005];
 
void init(){
	a.step = 0;b.step = 0;
	minn = 0x3f3f3f3f;
	memset(m,0,sizeof(m));
	while(!q.empty()) q.pop();
}
 
int ex_change(char s[]){
	int num = 0, cnt = 3;
	for(int i=0; i<strlen(s); ++i){
		num += (s[i]-'0') * int(pow(10,cnt--));
	}
	return num;
}
 
bool judge(char a1[], char a2[]){
	int len = strlen(a1);
	if(len != strlen(a2)) return false;
	for(int i=0; i<len; ++i){
		if(a1[i] != a2[i]) return false;
	}
	return true;
}
 
void bfs(){
	q.push(a);
	node c;
	while(!q.empty()){
		c = q.front();
		q.pop();
		m[ex_change(c.s)] += 1;
		//cout << b.s << " " << c.s << " " << judge(b.s,c.s) << endl;
		//cout << strcmp(b.s,c.s) << endl;
		if(!strcmp(b.s,c.s)){
			printf("%d\n",c.step);
			return;
		}
		for(int i=0; i<4; ++i){
			for(int j=0; j<10; ++j){
				node new_c = c;
				new_c.s[i] = '0' + j;
				if(new_c.s[0] == '0') continue;
				if(!v[ex_change(new_c.s)] || m[ex_change(new_c.s)]) continue;
				m[ex_change(new_c.s)] += 1;
				new_c.step = c.step + 1;
				q.push(new_c);
			} 
		}
	}
	printf("Impossible\n");
}
 
int main(){
	int t;
	for(int i=1000; i<10000; ++i){
		bool flag = true;
		for(int j=2; j*j<=i; ++j){
			if(i%j==0){
				flag = false;
				break;
			}
		}
		if(flag) v[i] = true;
	}
	scanf("%d",&t);
	while(t--){
		init();
		scanf("%s",a.s);
		scanf("%s",b.s);
		bfs();
	}
}

F - Shuffle’m Up

题意：
给你三个字符串，问第一个字符串和第二个字符串是否可以通过变换，组合成第三个字符串，变换规则如下：假设s1=12345,s2=67890，变换后的序列 s=6172839405，s1=61728,s2=39405

题解：
map水过，如果在变换过程中组合成的字符串在前面出现过，那么它将陷入一个“死循环”，永远组合不成目标字符串。

//
//Write by Yuan Xilan on 2019...
//
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long ll,LL;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
void R() {}
#ifdef HOME
 #define DEBUG(...) {printf("# ");printf(__VA_ARGS__);puts("");}
#else
 #define DEBUG(...)
#endif
const int maxn = 10;
int mod = 1e9+7;
int n,num;
struct node{
	
};
queue<node>q;
int startX, startY;
const int Move[4][2] = {{0,1},{0,-1},{-1,0},{1,0}};
bool vis[maxn][maxn];
map<string, int>m;
int fath[100100];
int len;
node a;
string s1;
string s2;
string s3;
string s;

int main(){
	int t;
	while(~scanf("%d",&t)){
		int cnt = 0;
		while(t--){
			m.clear();
			cin >> len;
			cin >> s1 >> s2 >> s3;
			int num = 1;
			while(1){
				s = "";
				for(int i=0; i<len; ++i){
					s += s2[i];
					s += s1[i];
				}
				if(s == s3){
					cout << ++cnt << " " << num << endl;
					break;
				}
				num += 1;
				if(m[s]){
					cout << ++cnt << " " << -1 << endl;
					break;
				}
				m[s] += 1;
				for(int i=0; i<len; ++i) s1[i] = s[i];
				for(int i=0; i<len; ++i) s2[i] = s[i+len];
			}
		}
	}
}

G - Pots

题意：
给定两个容器，问最少需要多少次操作可以使得任意一个杯子中体积为C，如果不存在输出-1.

题解：
裸bfs，在结构体中用father记录父代，最终递归输出即可。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
int a,b,c;

void choose(int x){
	if(x == 1) puts("FILL(1)");
	else if(x == 2) puts("FILL(2)");
	else if(x == 3) puts("POUR(1,2)");
	else if(x == 4) puts("POUR(2,1)");
	else if(x == 5) puts("DROP(1)");
	else if(x == 6) puts("DROP(2)");
}

bool vis[105][105];

struct node
{
	int left;
	int right;
	int father;
	int ope;
	/*
	node(int l, int r, int fa){
		left = l;
		right = r;
		father = fa;
	}
	*/
};

node q[20000];
int head = 0; 
int tail = 0;
int times = 0;

void print(node k){
	times += 1;
	if(k.father != -1){
		print(q[k.father]);
	}
	if(k.father == -1) cout << --times << endl;
	choose(k.ope);
}

void init(){
	memset(vis,0,sizeof(vis));
	memset(q,0,sizeof(q));
	head = 0;
	tail = 0;
	times = 0;
}

void bfs(){
	q[tail].left = 0; q[tail].right = 0; q[tail].father = -1;
	tail += 1;
	vis[0][0] = 1;
	while(head < tail){
		if(q[head].left == c || q[head].right == c){
			print(q[head]);
			return;
		}
		if(q[head].left != a){
			q[tail].left = a;
			q[tail].right = q[head].right;
			if(!vis[q[tail].left][q[tail].right]){
				vis[q[tail].left][q[tail].right] = 1;
				q[tail].father = head;
				q[tail].ope = 1;
				tail += 1;
			}
		}
		if(q[head].right != b){
			q[tail].left = q[head].left;
			q[tail].right = b;
			if(!vis[q[tail].left][q[tail].right]){
				vis[q[tail].left][q[tail].right] = 1;
				q[tail].father = head;
				q[tail].ope = 2;
				tail += 1;
			}
		}
		if(q[head].right != b){
			int need = b - q[head].right;
			if(q[head].left < need){
				q[tail].left = 0;
				q[tail].right = q[head].right + q[head].left;
				if(!vis[q[tail].left][q[tail].right]){
					vis[q[tail].left][q[tail].right] = 1;
					q[tail].father = head;
					q[tail].ope = 3;
					tail += 1;
				}
			}
			else{
				q[tail].left = q[head].left - need;
				q[tail].right = b;
				if(!vis[q[tail].left][q[tail].right]){
					vis[q[tail].left][q[tail].right] = 1;
					q[tail].father = head;
					q[tail].ope = 3;
					tail += 1;
				}
			}
		}
		if(q[head].left != a){
			int need = a - q[head].left;
			if(q[head].right < need){
				q[tail].right = 0;
				q[tail].left = q[head].left + q[head].right;
				if(!vis[q[tail].left][q[tail].right]){
					vis[q[tail].left][q[tail].right] = 1;
					q[tail].father = head;
					q[tail].ope = 4;
					tail += 1;
				}
			}
			else{
				q[tail].left = a;
				q[tail].right = q[head].right - need;
				if(!vis[q[tail].left][q[tail].right]){
					vis[q[tail].left][q[tail].right] = 1;
					q[tail].father = head;
					q[tail].ope = 4;
					tail += 1;
				}
			}
		}
		if(q[head].left != 0){
			q[tail].left = 0;
			q[tail].right = q[head].right;
			if(!vis[q[tail].left][q[tail].right]){
				vis[q[tail].left][q[tail].right] = 1;
				q[tail].father = head;
				q[tail].ope = 5;
				tail += 1;
			}
		}
		if(q[head].right != 0){
			q[tail].right = 0;
			q[tail].left = q[head].left;
			if(!vis[q[tail].left][q[tail].right]){
				vis[q[tail].left][q[tail].right] = 1;
				q[tail].father = head;
				q[tail].ope = 6;
				tail += 1;
			}
		}
		head += 1;
	}
	puts("impossible");
}

int main(){
	while(cin >> a >> b >> c){
		init();
		bfs();
	}
}

H - Oil Deposits

题意：
在n*m的图中’@'表示该处藏有石油，如果这些蕴藏石油的小方格相邻（横向相邻，纵向相邻，还有对角相邻），那么它们被认为是同一油藏的一部分，问这些石油组成多少部分。

题解：
裸bfs。

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int maxn = 222;
char s[maxn][maxn];
bool vis[maxn][maxn];
int step[maxn][maxn][maxn];
int num = 0;
int n,m,h;
int startX, startY, startZ, endX, endY, endZ;
//const int Move[6][3] = {{0,0,1},{0,0,-1},{0,1,0},{0,-1,0},{1,0,0},{-1,0,0}};
const int Move[8][2] = {{0,1},{0,-1},{-1,0},{1,0},{1,1},{1,-1},{-1,1},{-1,-1}};
int minn;

struct node{
	int x;
	int y;
	int num;
};

queue<node>q;
node st;
node End;

void init(){
	while(!q.empty()) q.pop();
	memset(vis,false,sizeof(vis));
}

inline bool check(int x, int y){
	if(x >= 0 && x < n && y >= 0 && y < m && !vis[x][y] && s[x][y] == '@') return true;
	return false;
}

void bfs(){
	node cur;
	cur.x = startX;
	cur.y = startY;
	q.push(cur);
	vis[cur.x][cur.y] = 1;
	while(!q.empty()){
		cur = q.front();
		q.pop();
		for(int i=0; i<8; ++i){
			int tx = cur.x + Move[i][0];
			int ty = cur.y + Move[i][1];
			if(check(tx,ty)){
				vis[tx][ty] = 1;
				node k;
				k.x = tx; k.y = ty;
				q.push(k);
			}
		}
	}
}


int main(){
	while(~scanf("%d%d",&n,&m)){
		if(m == 0) break;
		init();
		int sum = 0;
		for(int i=0; i<n; ++i){
			getchar();
			for(int j=0; j<m; ++j){
				scanf("%c",&s[i][j]);
			}
		}
		for(int i=0; i<n; ++i){
			for(int j=0; j<m; ++j){
				if(s[i][j] == '@' && !vis[i][j]){
					startX = i;
					startY = j;
					//cout << i << " " << j << endl;
					bfs();
					sum += 1;
				}
			}
		}
		cout << sum << endl;
	}
}

I - 非常可乐

题意：
有一杯可乐和两个杯子，询问最少的次数满足两个被子中的可乐平分。

题解：
可乐体积为奇数显然不满足，然后bfs遍历所有情况即可。

#include 
#include 
#include 
using namespace std;

int n,m,s;
bool vis[109][109][109];

struct node{
    int left;
    int mid;
    int right;
    int step;
};

queue<node>q;
node cnt;

void init(){
    memset(vis,0,sizeof(vis));
    while(!q.empty()) q.pop();
}

void bfs(){
    //cout << n << endl;
    q.push(cnt);
    while(!q.empty()){
        node k = q.front();
        q.pop();
        //cout << k.left << " " << k.mid << " " << k.right << " " << k.step << endl;
        if((k.left == n && k.mid == n) || (k.left == n && k.right == n) || (k.mid == n && k.right == n)){
            cout << k.step << endl;
            //cout << k.left << " " << k.mid << " " << k.right << endl;
            return;
        }
        node new_k = k;
        if(k.left != 0){
            new_k.left -= (m - new_k.mid);
            new_k.mid = m;//1往2倒
            new_k.step += 1;
            if(!vis[new_k.left][new_k.mid][new_k.right])
            q.push(new_k);
            vis[new_k.left][new_k.mid][new_k.right] = 1;
        }
        new_k = k;
        if(k.left != 0){
            new_k.left -= (s - new_k.right);
            new_k.right = s;//1往3倒
            new_k.step += 1;
            if(!vis[new_k.left][new_k.mid][new_k.right])
            q.push(new_k);
            vis[new_k.left][new_k.mid][new_k.right] = 1;
        }
        new_k = k;
        if(k.mid != 0){
            new_k.mid = 0;
            new_k.left += k.mid;//2往1倒
            new_k.step += 1;
            if(!vis[new_k.left][new_k.mid][new_k.right])
            q.push(new_k);
            vis[new_k.left][new_k.mid][new_k.right] = 1;
        }
        new_k = k;
        if(k.mid != 0){
            if(k.mid < s - k.right) new_k.mid = 0, new_k.right += k.mid;
            else new_k.mid -= (s - k.right), new_k.right = s;
            new_k.step += 1;
            if(!vis[new_k.left][new_k.mid][new_k.right])
            q.push(new_k);
            vis[new_k.left][new_k.mid][new_k.right] = 1;
        }
        new_k = k;
        if(k.right != 0){
            new_k.left += k.right;
            new_k.right = 0;
            new_k.step += 1;
            if(!vis[new_k.left][new_k.mid][new_k.right])
            q.push(new_k);
            vis[new_k.left][new_k.mid][new_k.right] = 1;
        }
        new_k = k;
        if(k.right != 0){
            if(k.right < m - k.mid) new_k.mid += k.right, new_k.right = 0;
            else new_k.mid = m, new_k.right -= (m - k.mid);
            new_k.step += 1;
            if(!vis[new_k.left][new_k.mid][new_k.right])
            q.push(new_k);
            vis[new_k.left][new_k.mid][new_k.right] = 1;
        }
        //cout << q.size() << endl;
    }
    puts("NO");
}

int main(){
    while(~scanf("%d%d%d",&n,&m,&s)){
        if(n == 0) break;
        if(n % 2 != 0){
            puts("NO");
            continue;
        }
        init();
        cnt.left = n; cnt.mid = 0; cnt.right = 0;
        n /= 2;
        bfs();
    }
}

J - Find a way

题意：
两个人出发，有多个KFC，询问两个人到同一个KFC的最短路径。

题解：
对两个点跑两次bfs，然后用两个二维数组记录两个人到每个KFC的距离，维护距离最小值即可。

AC_Code:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
int n,m;

bool vis[205][205];
char s[205][205];
int a[205][205];
int b[205][205];
const int Move[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};

struct node
{
	int x;
	int y;
	int step;
	node(){}
	node(int xx, int yy, int st){
		x = xx;
		y = yy;
		step = st;
	}
};

queue<node>q;
node p1,p2;

void init(){
	memset(vis,0,sizeof(vis));
	while(!q.empty()) q.pop();
}

void bfs1(node k){
	q.push(k);
	while(!q.empty()){
		node new_k = q.front();
		q.pop();
		for(int i=0; i<4; ++i){
			int tx = new_k.x + Move[i][0];
			int ty = new_k.y + Move[i][1];
			if(tx >= 0 && tx < n && ty >= 0 && ty < m && !vis[tx][ty] && s[tx][ty] != '#'){
				if(s[tx][ty] == '@'){
					a[tx][ty] = new_k.step + 1;
				}
				vis[tx][ty] = 1;
				node ppp = node(tx,ty,new_k.step+1);
				q.push(ppp);
			}
		}
 	}
}

void bfs2(node k){
	q.push(k);
	while(!q.empty()){
		node new_k = q.front();
		q.pop();
		for(int i=0; i<4; ++i){
			int tx = new_k.x + Move[i][0];
			int ty = new_k.y + Move[i][1];
			if(tx >= 0 && tx < n && ty >= 0 && ty < m && !vis[tx][ty] && s[tx][ty] != '#'){
				if(s[tx][ty] == '@'){
					b[tx][ty] = new_k.step + 1;
				}
				vis[tx][ty] = 1;
				node ppp = node(tx,ty,new_k.step+1);
				q.push(ppp);
			}
		}
 	}
}

int main(){
	while(~scanf("%d%d",&n,&m)){
		init();
		memset(a,0,sizeof(a));
		memset(b,0,sizeof(b));
		for(int i=0; i<n; ++i){
			scanf("%s",s[i]);
		}
		for(int i=0; i<n; ++i){
			for(int j=0; j<m; ++j){
				if(s[i][j] == 'Y'){
					p1 = node(i,j,0);
					vis[i][j] = 1;
				}
				if(s[i][j] == 'M'){
					p2 = node(i,j,0);
					vis[i][j] = 1;
				}
			}
		}
		bfs1(p1);
		init();
		for(int i=0; i<n; ++i){
			for(int j=0; j<m; ++j){
				if(s[i][j] == 'Y'){
					p1 = node(i,j,0);
					vis[i][j] = 1;
				}
				if(s[i][j] == 'M'){
					p2 = node(i,j,0);
					vis[i][j] = 1;
				}
			}
		}
		bfs2(p2);
		int minn = 0x3f3f3f3f;
		for(int i=0; i<n; ++i){
			for(int j=0; j<m; ++j){
				if(s[i][j] == '@' && vis[i][j]){
					//cout << i << " " << j << " " << a[i][j] << " " << b[i][j] << endl;
					minn = min(minn, a[i][j] + b[i][j]);
				}
			}
		}
		cout << minn * 11 << endl;
	}
}

K - 马走日

题意：
给定n*m大小的棋盘，以及马的初始位置(x，y)，要求不能重复经过棋盘上的同一个点，计算马可以有多少途径遍历棋盘上的所有点。

题解：
裸dfs。

#include 
#include 
#include 
#include 
using namespace std;

int n,m;
int startX, startY;
int num;
bool vis[20][20];
int Move[9][2] = {{0,0},{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,1},{2,-1}};

void init(){
	num = 0;
	memset(vis,false,sizeof(vis));
}

bool kiss(int x, int y){
	if(x >= 0 && x < n && y >= 0 && y < m && !vis[x][y]) return true;
	return false;
}

void dfs(int x, int y, int step){
	if(step == n * m){
		num++;
		return;
	}
	for(int i=0; i<9; ++i){
		int tx = x + Move[i][0];
		int ty = y + Move[i][1];
		if(kiss(tx,ty)){
			vis[tx][ty] = true;
			dfs(tx,ty,step+1);
			vis[tx][ty] = false;
		}
	}
}

int main(){
	int t;
	while(~scanf("%d",&t)){
		while(t--){
			init();
			scanf("%d%d%d%d",&n,&m,&startX,&startY);
			vis[startX][startY] = true;
			dfs(startX,startY,1);
			printf("%d\n",num);
		}
	}
}

L - 海贼王之伟大航路

没思路，待补。

M - 迷宫问题

题意：
输出一个二维迷宫从左上角到右下角最短路径。

题解：
由于要输出路径，因此不能用queue 弹出，手写队列（由于数据小，不会出现爆栈情况）记录路径。

AC_Code:

//
//Write by Yuan Xilan on 2019...
//
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long ll,LL;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
void R() {}
#ifdef HOME
 #define DEBUG(...) {printf("# ");printf(__VA_ARGS__);puts("");}
#else
 #define DEBUG(...)
#endif
const int maxn = 10;
ll a[maxn],b[maxn];
int mod = 1e9+7;
int n,m,num;
struct node{
	int x;
	int y;
	int father;
};
node q[20000];
char s[maxn][maxn];
int startX, startY;
const int Move[4][2] = {{0,1},{0,-1},{-1,0},{1,0}};
bool vis[maxn][maxn];
int fath[100100];

void print(int x){
	if(q[x].father != -1){
		print(q[x].father);
	}
	printf("(%d, %d)\n",q[x].x,q[x].y);
}

void bfs(){
	int head = 0, tail = 0;
	q[tail].x = 0; q[tail].y = 0; q[tail].father = -1;
	vis[0][0] = 1;
	tail += 1;
	while(head < tail){
		bool flag = false;
		for(int i=0; i<4; ++i){
			int tx = q[head].x + Move[i][0];
			int ty = q[head].y + Move[i][1];
			if(tx >= 0 && tx < 5 && ty >= 0 && ty < 5 && !vis[tx][ty] && s[tx][ty] == '0'){
				q[tail].x = tx; q[tail].y = ty; q[tail].father = head;
				vis[tx][ty] += 1;
				tail += 1;
			}
			if(tx == 4 && ty == 4){
				tail -= 1;
				print(tail);
			}
		}
		head += 1;
	}
}

int main(){
	for(int i=0; i<5; ++i){
		for(int j=0; j<5; ++j){
			scanf("%s",&s[i][j]);
		}
		getchar();
	}
	bfs();
}

N - 鸣人和佐助

题意：
鸣人可以往上下左右四个方向移动，每移动一个距离需要花费1个单位时间，打败大蛇丸的手下不需要时间。鸣人有一定数量的查克拉，每一个单位的查克拉可以打败一个大蛇丸的手下。如果鸣人查克拉消耗完了，则只可以走到没有大蛇丸手下的位置，不可以再移动到有大蛇丸手下的位置。佐助在此期间不移动，大蛇丸的手下也不移动。请问，鸣人要追上佐助最少需要花费多少时间？

题解:
单独跑bfs找到的路径不一定是时间最短的路径，因此使用优先队列，考虑每个队列中鸣人的时间和所需的查克拉，如果时间相等，则优先跑查克拉小的点，否则跑时间小的点，当所需查克拉大于手里有的查克拉时退出。

AC_Code:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
const int maxn = 222;
char s[maxn][maxn];
bool vis[maxn][maxn];
int num = 0;
int n,m,h;
int startX, startY, startZ, endX, endY, endZ;
//const int Move[6][3] = {{0,0,1},{0,0,-1},{0,1,0},{0,-1,0},{1,0,0},{-1,0,0}};
const int Move[4][2] = {{0,1},{0,-1},{-1,0},{1,0}};
int minn;

struct node{
	int x;
	int y;
	int num;
	int step;
	
	friend bool operator <(const node A, const node B){
		if(A.step == B.step) return A.num > B.num;
		return A.step > B.step;
	}
	
	/*
	bool operator < (const node &a) const //按照查克拉最小值优先 结构体优先队列 
	{
		if(a.step==step)
		{
			return a.num
};

priority_queue<node>q;
node st;
node End;

void init(){
	while(!q.empty()) q.pop();
	memset(vis,false,sizeof(vis));
}

inline bool check(int x, int y){
	if(x >= 0 && x < n && y >= 0 && y < m && !vis[x][y]) return true;
	return false;
}

void bfs(){
	node cur;
	q.push(st);
	while(!q.empty()){
		cur = q.top();
		q.pop();
		//cout << cur.num << endl;
		if(cur.num > h) continue;
		for(int i=0; i<4; ++i){
			int tx = cur.x + Move[i][0];
			int ty = cur.y + Move[i][1];
			if(tx == End.x && ty == End.y){
				printf("%d\n",cur.step + 1);
				return;
			}
			if(check(tx,ty)){
				node k;
				//cout << tx << " " << ty << endl;
				k.x = tx; k.y = ty; k.step = cur.step + 1;
				if(s[tx][ty] == '#') k.num = cur.num + 1;
				else k.num = cur.num;
				vis[tx][ty] = 1;
				q.push(k);
			}
		}
	}
	printf("-1\n");
}


int main(){
	int t;
	int ans = 1;
	scanf("%d%d%d",&n,&m,&h);
		for(int i=0; i<n; ++i){
			getchar();
			for(int j=0; j<m; ++j){
				scanf("%c",&s[i][j]);
			}
		}
		
		for(int i=0; i<n; ++i){
			for(int j=0; j<m; ++j){
				if(s[i][j] == '@'){
					startX = i;
					startY = j;
				}
				if(s[i][j] == '+'){
					End.x = i; End.y = j;
				}
			}
		}
		st.x = startX; st.y = startY; st.num = 0; st.step = 0;
		vis[startX][startY] = 1;
		bfs();
}

O - 红与黑

题意：
一个人从起点‘@’出发，问他可以到多少个’.’，此人不能通过’#’.

题解：
裸dfs。

//
//Write by Yuan Xilan on 2019...
//
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long ll,LL;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
void R() {}
#ifdef HOME
 #define DEBUG(...) {printf("# ");printf(__VA_ARGS__);puts("");}
#else
 #define DEBUG(...)
#endif
const int maxn = 30;
ll a[maxn],b[maxn];
int mod = 1e9+7;
int n,m,num;
struct node{
	ll s1;	
};
node c;
queue<node>q;
char s[maxn][maxn];
int startX, startY;
const int Move[4][2] = {{0,1},{0,-1},{-1,0},{1,0}};
bool vis[maxn][maxn];

void dfs(int x, int y, int step){
	num++;
	for(int i=0; i<4; ++i){
		int tx = x + Move[i][0];
		int ty = y + Move[i][1];
		if(tx >= 0 && tx < n && ty >= 0 && ty < m && !vis[tx][ty] && s[tx][ty] == '.'){
			vis[tx][ty] = 1;
			dfs(tx,ty,step+1);
		}
	}
}

int main(){
	while(~scanf("%d%d",&m,&n) && m && n){
		num = 0;
		memset(vis,false,sizeof(vis));
		for(int i=0; i<n; ++i){
			scanf("%s",s[i]);
		}
		for(int i=0; i<n; ++i){
			for(int j=0; j<m; ++j){
				if(s[i][j] == '@'){
					startX = i;
					startY = j;
					break;
				}
			}
		}
		vis[startX][startY] = 1;
		dfs(startX, startY, 1);
		cout << num << endl;
	}
	
}

P - 棋盘问题

题意：
在一个给定形状的棋，要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，求摆放k个棋子的所有可行的摆放方案C。

题解：
从上往下遍历每个’#’，由于不能放在同一行，因此接下来的棋子应该往该行下面放，这样便能枚举所有的情况。

AC_Code:

#include 
using namespace std;

char s[10][10];
bool vis[10];
int n,k,num;

void init(){
    num = 0;
    memset(vis,0,sizeof(vis));
}

void dfs(int x, int y, int sum){
    if(sum == k){
        num += 1;
        return;
    }
    for(int i=x+1; i<n; ++i){
        for(int j=0; j<n; ++j){
            if(s[i][j] == '#' && !vis[j]){
                vis[j] = 1;
                dfs(i,j,sum+1);
                vis[j] = 0;
            }
        }
    }
}

int main(){
    while(~scanf("%d%d",&n,&k)){
        if(n == -1) break;
        init();
        for(int i=0; i<n; ++i){
            scanf("%s",s[i]);
        }
        dfs(-1,-1,0);
        cout << num << endl;
    }
}

Q - 拯救行动

题意：
骑士可以向上、下、左、右四个方向移动，每移动一个位置需要1个单位时间，杀死一个守卫需要花费额外的1个单位时间。计算拯救行动成功需要花费最短时间。

由于直接裸bfs找到的路径并不一定是花费时间最少的路径，因此采用优先队列处理，重载重新根据每个点所需的时间进行排序，然后bfs即可。

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int maxn = 222;
char s[maxn][maxn];
bool vis[maxn][maxn];
int step[maxn][maxn][maxn];
int num = 0;
int n,m,h;
int startX, startY, startZ, endX, endY, endZ;
//const int Move[6][3] = {{0,0,1},{0,0,-1},{0,1,0},{0,-1,0},{1,0,0},{-1,0,0}};
const int Move[4][2] = {{0,1},{0,-1},{-1,0},{1,0}};
int minn;

struct node{
	int x;
	int y;
	int num;
	friend bool operator <(const node A,const node B){
		return A.num > B.num;
	}
};

priority_queue<node>q;
node st;
node End;

void init(){
	while(!q.empty()) q.pop();
	memset(vis,false,sizeof(vis));
	st.x = 0; st.y = 0;  st.num = 0;
	End.x = 0; End.y = 0;  End.num = 0;
}

inline bool check(int x, int y){
	if(x >= 0 && x < n && y >= 0 && y < m && !vis[x][y] && s[x][y] != '#') return true;
	return false;
}

void bfs(){
	node cur;
	q.push(st);
	vis[st.x][st.y] = 1;
	int minn = 0x3f3f3f3f;
	while(!q.empty()){
		cur = q.top();
		q.pop();
		for(int i=0; i<4; ++i){
			int tx = cur.x + Move[i][0];
			int ty = cur.y + Move[i][1];
			if(s[tx][ty] == 'a'){
				minn = min(minn, cur.num+1);
				//cout << cur.num + 1 << endl;
				//return;
			}
			if(check(tx,ty)){
				vis[tx][ty] = 1;
				node k;
				k.x = tx; k.y = ty; k.num = cur.num;
				if(s[tx][ty] == '@') k.num += 1;
				else if(s[tx][ty] == 'x') k.num += 2;
				q.push(k);
			}
		}
	}
	if(minn == 0x3f3f3f3f) 
		printf("Impossible\n");
	else cout << minn << endl;
}


int main(){
	int t;
	while(~scanf("%d",&t)){
		while(t--){
			init();
			scanf("%d%d",&n,&m);
			for(int i=0; i<n; ++i){
				getchar();
				for(int j=0; j<m; ++j){
					scanf("%c",&s[i][j]);
					if(s[i][j] == 'r'){
						startX = i;
						startY = j;
					}
					if(s[i][j] == 'a'){
						endX = i;
						endY = j;
					}
				}
			}
			st.x = startX; st.y = startY; st.num = 0;
			bfs();
		}
	}
}

/*
2 5
@@@@@
rxxxa
*/

R - Saving Tang Monk

题意：
要从K走到T处，并且要先收集k把钥匙，收集钥匙顺序递增，即拿到第一把钥匙才能拿到第二把钥匙，还有不超过五条蛇‘S’（之前没看到这里只有五条不会做），每次打蛇要+1s，蛇死了再路过是不用打的。

题意：
只有五条蛇，给蛇编号然后状压记录打的蛇的状态。剩下的就BFS。（还不是很理解）

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
int n,m;

bool vis[205][205][10];
char s[205][205];
char mp[205][205];
const int Move[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};

struct node
{
	int x;
	int y;
	int step;
	int key;
	int snake;
	node(){}
	node(int new_x, int new_y, int new_step, int new_key, int new_snake){
		x = new_x;
		y = new_y;
		step = new_step;
		key = new_key;
		snake = new_snake;
	}
	friend bool operator < (const node P, const node Q){
		return P.step > Q.step;
	}
};

priority_queue<node>q;
node Start;
node End;
int ans = 1;

void init(){
	while(!q.empty()) q.pop();
	memset(vis,0,sizeof(vis));
}

bool judge(int x, int y){
	if(x >= 0 && x < n && y >= 0 && y < n && s[x][y] != '#') return true;
	return false;
}

bool judge_s(node p, int x){
	if(p.snake & (1 << x)) return false;
	return true;
}

void bfs(){
	q.push(Start);
	vis[Start.x][Start.y][0] = 1;
	while(!q.empty()){
		node k = q.top();
		q.pop();
		for(int i=0; i<4; ++i){
			int tx = k.x + Move[i][0];
			int ty = k.y + Move[i][1];
			//cout << tx << " " << ty << " " << k.step << " " << k.cnt << endl;
			if(judge(tx,ty) && !vis[tx][ty][k.key]){
				//cout << tx << " " << ty << " " << k.step << " " << k.cnt << endl;
				if(k.key == m && s[tx][ty] == 'T'){
					cout << k.step + 1 << endl;
					return;
				}
				else if(s[tx][ty] == k.key + '0' + 1){//拿到钥匙
					vis[tx][ty][k.key] = 1;
					node new_k = node(tx,ty,k.step+1,k.key+1,k.snake);
					q.push(new_k);
				}
				else if(s[tx][ty] >= 0 && s[tx][ty] <= 5 && judge_s(k,s[tx][ty])){//遇到蛇
					vis[tx][ty][k.key] = 1;
					node new_k = node(tx,ty,k.step+2,k.key,k.snake|(1<<s[tx][ty]));
					q.push(new_k);
				}
				else{
					vis[tx][ty][k.key] = 1;
					node new_k = node(tx,ty,k.step+1,k.key,k.snake);
					q.push(new_k);
				}
			}
		}
	}
	printf("impossible\n");
}

int main(){
	while(~scanf("%d%d",&n,&m)){
		init();
		if(n == 0) break;
		for(int i=0; i<n; ++i){
			scanf("%s",s[i]);
		}
		int cnt = 0;
		for(int i=0; i<n; ++i){
			for(int j=0; j<n; ++j){
				if(s[i][j] == 'K'){
					Start = node(i,j,0,0,0);
					//vis[i][j] = 1;
				}
				if(s[i][j] == 'T'){
					End = node(i,j,0,m,0);
				}
				if(s[i][j] == 'S'){
					s[i][j] = cnt++;
				}
			}
		}
		bfs();
	}
}

S - Fire Game

题意：
两个熊孩子在n*m的平地上放火玩，#表示草，两个熊孩子分别选一个#格子点火，火可以向上向下向左向右在有草的格子蔓延，点火的地方时间为0，蔓延至下一格的时间依次加一。求烧完所有的草需要的最少时间。如不能烧完输出-1。（两个火同时点）

题解：

AC_Code:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define MST(a, b) memset(a, b, sizeof(a))
using namespace std;
typedef long long ll;
const int MAXN = 15;
const int INF = 0x3f3f3f3f;
char mp[MAXN][MAXN];
bool vis[MAXN][MAXN];
int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
struct node {
	int x, y, cnt;
	node(int _x, int _y, int _c) {
		x = _x;
		y = _y;
		cnt = _c;
	}
	node() {}
} ;
vector <node> grass;
int n, m, t, res;
void init() {
	res = INF;
	grass.clear();
	MST(mp, 0);
}
void bfs(node s1, node s2) {
	MST(vis, false);
	queue <node> q;
	q.push(s1);
	q.push(s2);
	vis[s1.x][s1.y] = vis[s2.x][s2.y] = true;
	node now, next;
	int sum = 0;
	while (!q.empty()) {
		now = q.front();
		q.pop();
		if (mp[now.x][now.y] == '#') sum++;
//        cout << now.x << " " << now.y << " " << now.cnt << " " << sum << endl;
		if (sum == grass.size()) {
			res = min(res, now.cnt);
		}
		for (int i = 0; i < 4; i++) {
			next.x = now.x + dir[i][1];
			next.y = now.y + dir[i][0];
			next.cnt = now.cnt + 1;
			if (next.x < 0 || next.y < 0 || next.x >= n || next.y >= m) continue;
			if (vis[next.x][next.y] || mp[next.x][next.y] == '.') continue;
			vis[next.x][next.y] = true;
			q.push(next);
		}
	}
}
int main() {
	ios::sync_with_stdio(false);
	cin >> t;
	for (int tt = 1; tt <= t; tt++) {
		init();
		cin >> n >> m;
		for (int i = 0; i < n; i++)
			for (int j = 0; j < m; j++) {
				cin >> mp[i][j];
				if (mp[i][j] == '#') {
					node tmpnd;
					tmpnd.x = i;
					tmpnd.y = j;
					tmpnd.cnt = 0;
					grass.push_back(tmpnd);
				}
			}
//        cout << grass.size() << endl;
		for (int i = 0; i < grass.size(); i++)
			for (int j = i; j < grass.size(); j++)
				bfs(grass[i], grass[j]);
		cout << "Case " << tt << ": ";
		if (res != INF) cout << res << endl;
		else cout << "-1" << endl;
	}
}

T - Fire!

题意：
一个人从J出发，同时火从F处开始燃烧，每1s火往上下左右扩散，人可以往上下左右移动一格，‘#’表示墙壁，逃离边界即可避免火灾，询问是否可以安全逃离。（PS：本题坑：F不止一处,也可能没F（数据并无体现。。。））

题解：
特判没有火的情况（裸bfs），然后考虑有火的情况，每一秒先处理火先烧的区域，vis数组标记，然后人再移动，bfs即可。

AC_Code:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
const int maxn = 1222;
string s[maxn];
bool vis[maxn][maxn];
int num = 0;
int n,m,h;
int startX, startY, startZ, endX, endY, endZ;
//const int Move[6][3] = {{0,0,1},{0,0,-1},{0,1,0},{0,-1,0},{1,0,0},{-1,0,0}};
const int Move[4][2] = {{0,1},{0,-1},{-1,0},{1,0}};
int minn;

struct node{
	int x;
	int y;
	int num;
};

queue<node>q;
queue<node>new_q;
queue<node>f;
queue<node>new_f;
node st;
node End;

void init(){
	while(!q.empty()) q.pop();
	while(!f.empty()) f.pop();
	while(!new_f.empty()) new_f.pop();
	while(!new_q.empty()) new_q.pop();
	memset(vis,false,sizeof(vis));
}

inline bool check(int x, int y){
	if(x >= 0 && x < n && y >= 0 && y < m && !vis[x][y] && s[x][y] != '#') return true;
	return false;
}

void bfs(){
	node cur;
	node fire;
	q.push(st);
	//cout << q.empty() << " " << f.size() << endl;为空返回1
	
	if(f.size() == 0){
		while(!q.empty()){
			node test = q.front();
			q.pop();
			for(int i=0; i<4; ++i){
				int tx = test.x + Move[i][0];
				int ty = test.y + Move[i][1];
				if(tx < 0 || tx >= n || ty < 0 || ty >= m){
					cout << test.num + 1 << endl;
					return;
				}
				if(!vis[tx][ty] && s[tx][ty] != '#'){
					vis[tx][ty] = 1;
					node k;
					k.x = tx; k.y = ty; k.num = test.num + 1;
					q.push(k);
				}
			}
		}
	}

	while(!q.empty() || !f.empty()){

		//cout << f.size() << endl;
		while(!f.empty()){
			fire = f.front();
			f.pop();
			for(int i=0; i<4; ++i){
				int tx = fire.x + Move[i][0];
				int ty = fire.y + Move[i][1];
				if(check(tx,ty)){
					vis[tx][ty] = 1;
					node k;
					k.x = tx; k.y = ty; k.num = 0;
					//cout << k.x << " " << k.y << endl;
					new_f.push(k);
				}
			}
		}
		while(!new_f.empty()){
			f.push(new_f.front());
			new_f.pop();
		}
		
		while(!q.empty()){
			cur = q.front();
			q.pop();
			for(int i=0; i<4; ++i){
				int tx = cur.x + Move[i][0];
				int ty = cur.y + Move[i][1];
				if(tx < 0 || tx >= n || ty < 0 || ty >= m){
					//cout << cur.x << " " << cur.y << " " << cur.num << endl;
					cout << cur.num + 1 << endl;
					return;
				}
				if(!vis[tx][ty] && s[tx][ty] != '#'){
					vis[tx][ty] = 1;
					node k;
					k.x = tx; k.y = ty; k.num = cur.num + 1;
					//cout << k.x << " " << k.y << " " << k.num << endl;
					new_q.push(k);
				}
			}
		}
		while(!new_q.empty()){
			q.push(new_q.front());
			new_q.pop();
		}
	}
	printf("IMPOSSIBLE\n");
}


int main(){
	int t;
	int ans = 1;
	
		cin >> n >> m;
		init();
		for(int i=0; i<n; ++i){
			cin >> s[i];
		}
		for(int i=0; i<n; ++i){
			for(int j=0; j<m; ++j){
				if(s[i][j] == 'J'){
					startX = i;
					startY = j;
				}
				if(s[i][j] == 'F'){
					End.x = i; End.y = j;
					vis[i][j] = 1;
					f.push(End);
				}
			}
		}
		st.x = startX; st.y = startY; st.num = 0;
		vis[startX][startY] = 1;
		bfs();
	
}
/*
4 4
####
FJ..
...F
#...
*/
/*
4 5
FF#..
#...#
#.J.#
###.F
*/
/*
5 5
#####
#...#
#.#.#
#J#.#
###.#
*/
/*
6 4
####
#F.#
#.J#
#..#
#.#.
#...
*/////

U - Cops and Robbers

题意：
一帮盗贼从‘B’处出发，为了不让盗贼逃走，需建立围墙进行防卫，小写字母表示可以建立围墙，最后一行的输入表示对应的字母处建立围墙的金钱，’.'处盗贼可以通过但是不能建立围墙，询问最少需要多少金钱可防止盗贼逃走。

题解：
（待补）

你可能感兴趣的:([kuangbin带你飞]专题一简单搜索（大全）)

斤斤计较的婚姻到底有多难？白心之岂必有为
很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
芦花鞋一四许叶晗
又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
铭刻于星（四十二）随风至
69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说造命者说
底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
2020-01-25 晴岚85
郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
随笔 | 仙一般的灵气海思沧海
仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
想家爆米花机
也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
【iOS】MVC设计模式 Magnetic_h ios mvc 设计模式 objective-c 学习 ui
MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
一百九十四章. 自相矛盾巨木擎天
唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
element实现动态路由+面包屑软件技术NINI vue案例 vue.js 前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
地推话术，如何应对地推过程中家长的拒绝校师学
相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
谢谢你们，爱你们！鹿游儿
昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
小丽成长记（四十三）玲玲54321
小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
2021年12月19日，春蕾教育集团团建活动感受——黄晓丹黄错错加油
感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断尐尐呅
结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
瑶池防线谜影梦蝶
冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
爬山后遗症璃绛
爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
《策划经理回忆录之二》路基雅虎
话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
java工厂模式 3213213333332132 java 抽象工厂
工厂模式有 1、工厂方法 2、抽象工厂方法。下面我的实现是抽象工厂方法, 给所有具体的产品类定一个通用的接口。 package 工厂模式; /** * 航天飞行接口 * * @Description * @author FuJianyong * 2015-7-14下午02:42:05 */ public interface SpaceF
nginx频率限制+python测试 ronin47 nginx 频率 python
部分内容参考：http://www.abc3210.com/2013/web_04/82.shtml 首先说一下遇到这个问题是因为网站被攻击，阿里云报警，想到要限制一下访问频率，而不是限制ip（限制ip的方案稍后给出）。nginx连接资源被吃空返回状态码是502，添加本方案限制后返回599，与正常状态码区别开。步骤如下：
java线程和线程池的使用 dyy_gusi ThreadPool thread Runnable timer
java线程和线程池一、创建多线程的方式 java多线程很常见，如何使用多线程，如何创建线程，java中有两种方式，第一种是让自己的类实现Runnable接口，第二种是让自己的类继承Thread类。其实Thread类自己也是实现了Runnable接口。具体使用实例如下： 1、通过实现Runnable接口方式 1 2
Linux 171815164 linux
ubuntu kernel http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.1.2-unstable/ 安卓sdk代理 mirrors.neusoft.edu.cn 80 输入法和jdk sudo apt-get install fcitx su
Tomcat JDBC Connection Pool g21121 Connection
Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。 Tomcat Jdbc P
敲代码的一点想法永夜-极光 java 随笔感想
入门学习java编程已经半年了,一路敲代码下来,现在也才1w+行代码量,也就菜鸟水准吧,但是在整个学习过程中,我一直在想,为什么很多培训老师,网上的文章都是要我们背一些代码?比如学习Arraylist的时候,教师就让我们先参考源代码写一遍,然
jvm指令集程序员是怎么炼成的 jvm 指令集
转自：http://blog.csdn.net/hudashi/article/details/7062675#comments 将值推送至栈顶时 const ldc push load指令 const系列该系列命令主要负责把简单的数值类型送到栈顶。(从常量池或者局部变量push到栈顶时均使用) 0x02 &nbs
Oracle字符集的查看查询和Oracle字符集的设置修改 aijuans oracle
本文主要讨论以下几个部分：如何查看查询oracle字符集、修改设置字符集以及常见的oracle utf8字符集和oracle exp 字符集问题。一、什么是Oracle字符集 Oracle字符集是一个字节数据的解释的符号集合,有大小之分,有相互的包容关系。ORACLE 支持国家语言的体系结构允许你使用本地化语言来存储，处理，检索数据。它使数据库工具，错误消息，排序次序，日期，时间，货
png在Ie6下透明度处理方法 antonyup_2006 css 浏览器 Firebug IE
由于之前到深圳现场支撑上线，当时为了解决个控件下载，我机器上的IE8老报个错，不得以把ie8卸载掉，换个Ie6,问题解决了，今天出差回来，用ie6登入另一个正在开发的系统，遇到了Png图片的问题，当然升级到ie8(ie8自带的开发人员工具调试前端页面JS之类的还是比较方便的，和FireBug一样，呵呵)，这个问题就解决了，但稍微做了下这个问题的处理。我们知道PNG是图像文件存储格式，查询资
表查询常用命令高级查询方法(二) 百合不是茶 oracle 分页查询分组查询联合查询
----------------------------------------------------分组查询 group by having --平均工资和最高工资 select avg(sal)平均工资,max(sal) from emp ; --每个部门的平均工资和最高工资
uploadify3.1版本参数使用详解 bijian1013 JavaScript uploadify3.1
使用：绑定的界面元素<input id='gallery'type='file'/>$("#gallery").uploadify({设置参数，参数如下}); 设置的属性： id: jQuery(this).attr('id'),//绑定的input的ID langFile: 'http://ww
精通Oracle10编程SQL(17)使用ORACLE系统包 bijian1013 oracle 数据库 plsql
/* *使用ORACLE系统包 */ --1.DBMS_OUTPUT --ENABLE:用于激活过程PUT,PUT_LINE,NEW_LINE,GET_LINE和GET_LINES的调用 --语法：DBMS_OUTPUT.enable(buffer_size in integer default 20000); --DISABLE:用于禁止对过程PUT,PUT_LINE,NEW
【JVM一】JVM垃圾回收日志 bit1129 垃圾回收
将JVM垃圾回收的日志记录下来，对于分析垃圾回收的运行状态，进而调整内存分配(年轻代，老年代，永久代的内存分配)等是很有意义的。JVM与垃圾回收日志相关的参数包括： -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -Xloggc -XX:+PrintGC 通
Toast使用白糖_ toast
Android中的Toast是一种简易的消息提示框，toast提示框不能被用户点击，toast会根据用户设置的显示时间后自动消失。创建Toast 两个方法创建Toast makeText(Context context, int resId, int duration) 参数：context是toast显示在
angular.identity boyitech AngularJS AngularJS API
angular.identiy 描述: 返回它第一参数的函数. 此函数多用于函数是编程. 使用方法: angular.identity(value); 参数详解: Param Type Details value * to be returned. 返回值: 传入的value 实例代码: <!DOCTYPE HTML>
java-两整数相除，求循环节 bylijinnan java
import java.util.ArrayList; import java.util.List; public class CircleDigitsInDivision { /** * 题目：求循环节，若整除则返回NULL，否则返回char*指向循环节。先写思路。函数原型：char*get_circle_digits(unsigned k,unsigned j)
Java 日期周年 Chen.H java C++c C#
/** * java日期操作(月末、周末等的日期操作) * * @author * */ public class DateUtil { /** */ /** * 取得某天相加(减)後的那一天 * * @param date * @param num *
[高考与专业]欢迎广大高中毕业生加入自动控制与计算机应用专业 comsci 计算机
不知道现在的高校还设置这个宽口径专业没有,自动控制与计算机应用专业,我就是这个专业毕业的,这个专业的课程非常多,既要学习自动控制方面的课程,也要学习计算机专业的课程,对数学也要求比较高.....如果有这个专业,欢迎大家报考...毕业出来之后,就业的途径非常广..... 以后
分层查询（Hierarchical Queries） daizj oracle 递归查询层次查询
Hierarchical Queries If a table contains hierarchical data, then you can select rows in a hierarchical order using the hierarchical query clause: hierarchical_query_clause::= start with condi
数据迁移 daysinsun 数据迁移
最近公司在重构一个医疗系统，原来的系统是两个.Net系统，现需要重构到java中。数据库分别为SQL Server和Mysql，现需要将数据库统一为Hana数据库，发现了几个问题，但最后通过努力都解决了。 1、原本通过Hana的数据迁移工具把数据是可以迁移过去的，在MySQl里面的字段为TEXT类型的到Hana里面就存储不了了，最后不得不更改为clob。 2、在数据插入的时候有些字段特别长
C语言学习二进制的表示示例 dcj3sjt126com c basic
进制的表示示例 # include <stdio.h> int main(void) { int i = 0x32C; printf("i = %d\n", i); /* printf的用法 %d表示以十进制输出 %x或%X表示以十六进制的输出 %o表示以八进制输出 */ return 0; }
NsTimer 和 UITableViewCell 之间的控制 dcj3sjt126com ios
情况是这样的: 一个UITableView, 每个Cell的内容是我自定义的 viewA viewA上面有很多的动画, 我需要添加NSTimer来做动画, 由于TableView的复用机制, 我添加的动画会不断开启, 没有停止, 动画会执行越来越多. 解决办法: 在配置cell的时候开始动画, 然后在cell结束显示的时候停止动画查找cell结束显示的代理
MySql中case when then 的使用 fanxiaolong casewhenthenend
select "主键", "项目编号", "项目名称","项目创建时间", "项目状态","部门名称","创建人" union (select pp.id as "主键", pp.project_number as &
Ehcache（01）——简介、基本操作 234390216 cache ehcache 简介 CacheManager crud
Ehcache简介目录 1 CacheManager 1.1 构造方法构建 1.2 静态方法构建 2 Cache 2.1&
最容易懂的javascript闭包学习入门 jackyrong JavaScript
http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。下面就是我的学习笔记，对于Javascript初学者应该是很有用的。一、变量的作用域要理解闭包，首先必须理解Javascript特殊
提升网站转化率的四步优化方案 php教程分享数据结构 PHP 数据挖掘 Google 活动
网站开发完成后,我们在进行网站优化最关键的问题就是如何提高整体的转化率，这也是营销策略里最最重要的方面之一，并且也是网站综合运营实例的结果。文中分享了四大优化策略：调查、研究、优化、评估，这四大策略可以很好地帮助用户设计出高效的优化方案。 PHP开发的网站优化一个网站最关键和棘手的是，如何提高整体的转化率，这是任何营销策略里最重要的方面之一，而提升网站转化率是网站综合运营实力的结果。今天，我就分
web开发里什么是HTML5的WebSocket？ naruto1990 Web html5 浏览器 socket
当前火起来的HTML5语言里面，很多学者们都还没有完全了解这语言的效果情况，我最喜欢的Web开发技术就是正迅速变得流行的 WebSocket API。WebSocket 提供了一个受欢迎的技术，以替代我们过去几年一直在用的Ajax技术。这个新的API提供了一个方法，从客户端使用简单的语法有效地推动消息到服务器。让我们看一看6个HTML5教程介绍里的 WebSocket API：它可用于客户端、服
Socket初步编程——简单实现群聊 Everyday都不同 socket 网络编程初步认识
初次接触到socket网络编程，也参考了网络上众前辈的文章。尝试自己也写了一下，记录下过程吧：服务端：（接收客户端消息并把它们打印出来） public class SocketServer { private List<Socket> socketList = new ArrayList<Socket>(); public s
面试：Hashtable与HashMap的区别（结合线程） toknowme
昨天去了某钱公司面试，面试过程中被问道 Hashtable与HashMap的区别？当时就是回答了一点，Hashtable是线程安全的，HashMap是线程不安全的，说白了，就是Hashtable是的同步的，HashMap不是同步的，需要额外的处理一下。今天就动手写了一个例子，直接看代码吧 package com.learn.lesson001; import java
MVC设计模式的总结 xp9802 设计模式 mvc 框架 IOC
随着Web应用的商业逻辑包含逐渐复杂的公式分析计算、决策支持等，使客户机越来越不堪重负，因此将系统的商业分离出来。单独形成一部分，这样三层结构产生了。其中‘层’是逻辑上的划分。三层体系结构是将整个系统划分为如图2.1所示的结构[3] （1）表现层（Presentation layer）：包含表示代码、用户交互GUI、数据验证。该层用于向客户端用户提供GUI交互，它允许用户

[kuangbin带你飞]专题一 简单搜索（大全）

目录

A - Dungeon Master

B - Catch That Cow

C - Fliptile

D - Find The Multiple

E - Prime Path

F - Shuffle’m Up

G - Pots

H - Oil Deposits

I - 非常可乐

J - Find a way

K - 马走日

L - 海贼王之伟大航路

M - 迷宫问题

N - 鸣人和佐助

O - 红与黑

P - 棋盘问题

Q - 拯救行动

R - Saving Tang Monk

S - Fire Game

T - Fire!

U - Cops and Robbers

你可能感兴趣的:([kuangbin带你飞]专题一 简单搜索（大全）)

[kuangbin带你飞]专题一简单搜索（大全）

你可能感兴趣的:([kuangbin带你飞]专题一简单搜索（大全）)