代不在‘

[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带你飞]专题一简单搜索（大全）)

OCR字符识别--WeChatocr 鲁鲁在川 ocr
导入库，及定义微信OCR地址fromwechat_ocr.ocr_managerimportOcrManager,OCR_MAX_TASK_IDimportthreadingwechat_ocr_dir=r"./ocr/WeChatOCR/7079/extracted"#OCR的地址，可以用everythin工具查找一下地址这个地址是电脑用户安装APP的地址---C:\Users\xxxx\App
Hive中没有超级管理员，如何进行权限控制二进制_博客大数据 hive hadoop 数据仓库
Hive中没有超级管理员，任何用户都可以进行Grant/Revoke操作开发实现自己的权限控制类，确保某个用户为超级用户比如任何用户都可以grant权限给别的用户。grantselectontabletest2touserhadoop;如何开发一个超级管理员：创建一个项目，导入mavanjar包，然后开始编写hook类importcom.google.common.base.Joiner;impo
1.8 GPT-4：开创人工智能的新纪元少林码僧 AI大模型应用实战专栏人工智能
GPT-4：开创人工智能的新纪元自从OpenAI推出GPT-4以来，人工智能领域经历了显著的突破。作为“生成预训练转换器”家族中的最新成员，GPT-4不仅在功能上进行了提升，更在语言处理能力、理解深度以及适应性方面带来了全新的变革。本篇文章将深入探讨GPT-4的特点、创新以及它如何定义未来人工智能技术的发展。GPT-4的技术亮点1.规模与深度的进一步提升GPT-4的规模比前代模型更大，训练数据量和
华为OD机试E卷 --跳格子3 --24年OD统一考试（Java & JS & Python & C & C++）飞码创造者最新华为OD机试题库2024 华为od java javascript python c语言
文章目录题目描述输入描述输出描述用例题目解析JS算法源码Java算法源码python算法源码c++算法源码题目描述小明和朋友们一起玩跳格子游戏，每个格子上有特定的分数score=[1,-1,-6,7,-17,7]，从起点score[0]开始，每次最大的步长为k，请你返回小明跳到终点score[n-1]时，能得到的最大得分。输入描述第一行输入总的格子数量n第二行输入每个格子的分数score[i]第三
Elasticsearch 实战应用周盛欢搜索引擎 elasticsearch jenkins
一、啥是Elasticsearch嘿，小伙伴们，今天给大家唠唠Elasticsearch。简单来说，它就是一个超厉害的搜索引擎，就像我们平时用的百度、谷歌一样，但它是专门给开发者用的，能帮你在海量数据里快速找到想要的东西。二、为啥要用Elasticsearch想象一下，你有个电商网站，商品信息多得跟天上的星星似的。要是没有Elasticsearch，用户想搜个商品，得等半天才能出结果，那多糟心啊。
第83期 | GPTSecurity周报云起无垠 GPTSecurity 人工智能网络安全
GPTSecurity是一个涵盖了前沿学术研究和实践经验分享的社区，集成了生成预训练Transformer（GPT）、人工智能生成内容（AIGC）以及大语言模型（LLM）等安全领域应用的知识。在这里，您可以找到关于GPT/AIGC/LLM最新的研究论文、博客文章、实用的工具和预设指令（Prompts）。现为了更好地知悉近一周的贡献内容，现总结如下。SecurityPapers1.混乱中建立秩序：人
NVIDIA Hopper 架构深入 RZer 硬件工程架构 NVIDIA
在2022年NVIDIAGTC主题演讲中，NVIDIA首席执行官黄仁勋介绍了基于全新NVIDIAHopperGPU架构的全新NVIDIAH100TensorCoreGPU。文章目录前言一、NVIDIAH100TensorCoreGPU简介二、NVIDIAH100GPU主要功能概述1.新的流式多处理器（SM）具有许多性能和效率改进。主要新功能包括：2.新的transformer引擎结合使用软件和定制
腾讯cos对象存储，下行流量费贵，是否可以加入服务器减少费用，架构如何设计 iteye_10392 对象存储 java
腾讯云COS（CloudObjectStorage）对象存储服务提供了一种高效、安全、低成本的方式存储大量数据。然而，当涉及到外网下行流量时，确实会产生一定的费用，这可能会增加整体的成本。为了减少这些费用，可以通过以下几种方式优化架构设计：1.内网访问内网通信：如果您的应用服务器也在腾讯云上，尽量使用内网IP来访问COS。腾讯云通常不收取内网流量费用，这样可以大大减少成本。VPC互通：确保您的应用
[python]通过whl文件安装torchvision和torchaudio及国内whl文件下载地址汇总萌萌哒240 环境配置 python 开发语言
要通过.whl文件安装torchvision和torchaudio，你需要先确保你已经安装了与这些库兼容的PyTorch版本。以下是一个详细的步骤指南，帮助你通过.whl文件安装这些库。1.安装PyTorch首先，确保你已经安装了PyTorch。你可以从PyTorch的官方网站获取适合你系统的安装命令例如，如果你使用的是CUDA11.3和Python3.8，你可以使用以下命令安装PyTorch：p
vant组件库的按需导入导出 ordinary90 VUE 前端全栈开发 vue.js 前端
vant是一个基于Vue的移动端UI组件库，它提供了丰富的组件和样式，可以帮助我们快速构建移动端应用。在使用vant组件库时，可以通过按需导入导出的方式来减小打包体积，提高应用的性能。按需导入导出的原理是根据需要只加载使用到的组件和样式，而不是将整个组件库都打包到应用中。下面是一个使用vant组件库实现按需导入导出的详细解析和代码实例。安装vant组件库首先，在命令行中使用npm或者yarn安装v
记录 io.springfox 3.0.0 整合 spring boot 2.6.x 由于 springfox bug 引发问题树懒_Zz Spring spring boot bug windows
首先第一个问题就是不兼容：解决方案：@BeanpublicstaticBeanPostProcessorspringfoxHandlerProviderBeanPostProcessor(){returnnewBeanPostProcessor(){@OverridepublicObjectpostProcessAfterInitialization(Objectbean,StringbeanNa
设计模式-生成器模式(建造者模式)-(Builder) 树懒_Zz 设计模式建造者模式
生成器模式是一种创建型设计模式，使你能够分步骤创建复杂对象。该模式允许你使用相同的创建代码生成不同类型和形式的对象。就像流水线的组装机器人一样，一件产品组装分成好几部，每一个工位组装不同的内容。问题：譬如你开了一家公司，专门承接私人建房，建房有的人要求：自带车库的房子、带游泳池的房子、装饰豪华的房子和带花园的房子等等。如果你基于这些创建了一个构造函数：House(windows,doors,roo
重生之我在异世界学编程之算法与数据结构：算法复杂度介绍篇就爱学编程数据结构与算法算法数据结构排序算法
大家好，这里是小编的博客频道小编的博客：就爱学编程很高兴在CSDN这个大家庭与大家相识，希望能在这里与大家共同进步，共同收获更好的自己！！！本文目录引言正文一时间复杂度1.常数时间复杂度O(1)2.线性时间复杂度O(n)3.对数时间复杂度O(logn)4.平方时间复杂度O(n^2)5.指数时间复杂度O(2^n)二空间复杂度（1）空间复杂度的定义与重要性（2）常见的空间复杂度类型及介绍1.常数空间复
重生之我在异世界学编程之算法与数据结构：深入静态顺序表篇就爱学编程数据结构与算法算法数据结构
大家好，这里是小编的博客频道小编的博客：就爱学编程很高兴在CSDN这个大家庭与大家相识，希望能在这里与大家共同进步，共同收获更好的自己！！！本文目录引言正文一、顺序表的概念及结构1.顺序表的定义2.顺序表的结构3.顺序表的初始化二、顺序表的基本操作（静态）1.插入操作2.删除操作3.查找操作4.更新操作5.获取元素操作6.遍历操作7.求顺序表的长度8.判断顺序表是否为空快乐的时光总是短暂，咱们下篇
重生之我在异世界学编程之C语言：深入动态内存管理篇就爱学编程 C语言 c语言网络 android
大家好，这里是小编的博客频道小编的博客：就爱学编程很高兴在CSDN这个大家庭与大家相识，希望能在这里与大家共同进步，共同收获更好的自己！！！本文目录引言正文一动态内存管理的必要性二动态内存管理的关键函数1.`malloc`函数2.`calloc`函数3.`realloc`函数4.`free`函数三动态内存管理中的错误和最佳实践1.内存泄漏2.野指针3.内存越界四动态内存管理的高级主题内存分配器内存
Centos7.6离线安装软件 PascalMing Linux Centos yum ntp 离线安装
在离线情况下，安装Centos软件，有几个方法1、直接下载离线软件包如果能直接下载离线软件包，是最省事的方法，可以直接baidu查找试试，或到下面这个网址试试：PackagesforLinuxandUnix-pkgs.orgUbuntu各版本的软件比较齐全，下载后直接安装即可由于Centos目前逐步停止支持，导致不少安装包不容易找到，可以试试第2种方法2、使用yum的离线包下载功能yum将一个包下
GitLab：添加SSH密钥之前，您不能通过SSH来拉取或推送项目代码 dingcho 运维 gitlab ssh 运维
1、查看服务器是否配置过[root@kingbal-ecs-7612~]#cd.ssh/[[email protected]]#lsauthorized_keysid_ed25519id_ed25519.pubid_rsaid_rsa.pub2、创建密钥$ssh-keygen-trsa-C'[email protected]'#-C后写你的邮箱一路回车3、复制密钥[root@k
MySQL：下划线处理 dingcho 存储数据 mysql 数据库
要查询MySQL中不包含下划线的字符串，可以使用NOTLIKE操作符。以下是一个示例SQL查询，它选出所有不包含下划线的记录：SELECT*FROMyour_tableWHEREyour_columnNOTLIKE'%_%';这样其实是查询不出来记录的，我们需要将其转义一下SELECT*FROMyour_tableWHEREyour_columnNOTLIKE'%\_%';
C语言入门算法——明明的随机数 0X78 C语言算法 c语言数据结构
题目描述：明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数(N≤100)，对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。输入格式输入有两行，第1行为1个正整数，表示所生成的随机数的个数N。第2行有N个
性能场景之异常场景 wfw123123 性能测试 html5 物联网 java 压力测试
谈到异常场景，其实大家并不陌生，我们在做功能测试的时候，也要考虑异常用例，例如：切换网络，断网，中断使用等等。那么，性能中的异常场景，我们具体该怎么做呢？设计哪些问题才能将异常场景覆盖完整？这就需要我们明确两个关键点：一是异常场景的范围，二是异常场景的设计逻辑。异常场景的范围我理解的异常场景中，基本上采用的就是是宕主机、断网络、宕应用这几种测试手段。此外，从主机、网络、应用等角度出发，还会有一些细
Python：Numpy使用方法从小就看凹凸曼^o^ python numpy
一.生成数组1.快速生成数组importnumpyasnpa=np.array([1,2,3,4,5])#[12345]b=np.array(range(6,11,1))#[678910]c=np.arange(11,16,1)#[1112131415]d=np.linspace(16,20,5)#[16.17.18.19.20.]其中：np.array(range(......))←→np.ar
STM32的DMA作用嵌入式小强工作室 stm32 嵌入式硬件单片机
STM32的DMA（DirectMemoryAccess），即直接存储器存取，是一个重要的外设功能，它的主要作用是实现数据在外设和存储器之间或者存储器和存储器之间的高速传输，而无需CPU的干预。以下是对STM32的DMA作用的详细解释：数据高速传输：DMA能够在没有CPU参与的情况下，快速地将数据从一个地址传输到另一个地址。这种传输方式极大地提高了数据传输的速度，因为CPU无需在每个数据传输周期中
CAS一定有自旋吗？ IsToRestart java 开发语言
不一定，但是通常为了提高CAS的成功率，会考虑做自旋。最简单的自旋就是while(true)通常情况下，CAS操作都会采用自旋的方式，当CAS失败时，会重新尝试执行CAS操作，直到操作成功或达到最大重试次数为止。因为，CAS操作一般都是在多线程并发访问时使用，如果直接阻塞线程，会导致性能下降，而采用自旋的方式,可以让CPU空转一段时间，等待锁被释放，从而避免线程切换和阻塞的开销。但是，如果自旋时间
使用神经网络拟合6项参数 Andrew_Xzw 神经网络人工智能深度学习开发语言机器学习 python
使用神经网络拟合6项参数1.数据预处理1.1添加参数解析1.2数据预处理逻辑1.3数据归一化及划分1.4数据标签处理逻辑1.5数据转torch2.定义model2.1CNN_LSTM2.2Transformer3.定义train脚本3.1loss和optimizer3.2train3.3predict1.数据预处理1.1添加参数解析为了方便管理模型和训练等参数，统一用参数解析。defparse_a
Java 异常处理大哥的打嗝 JAVA java jvm servlet
Java是一种面向对象的编程语言，Java程序在运行时可能会发生各种异常，如空指针异常、文件读取异常、算术异常等。在Java中，异常是指程序运行时可能会发生的错误，例如输入不正确、内存不足等等，这些异常会影响程序的正常执行。因此，Java提供了异常处理机制来处理这些异常，以保证程序的稳定性和可靠性。Java中的异常处理机制是通过throw和try-catch语句实现的。在Java中，throw语句
TiDB Drems 凉兮分布式
架构原理及安装部署第一天：学习任务【PCTA备考指南1/16】TiDB架构原理及安装部署：https://asktug.com/t/topic/34500第二天：学习任务【PCTA备考指南2/16】TiDB使用管理手册：https://asktug.com/t/topic/34505第三天：学习任务【PCTA备考指南3/16】TiDB管理工具：https://asktug.com/t/topic/
Ubuntu问题集2.0 Glourier 小技巧 Linux ubuntu linux
目录1.实时显示网速、内存占用等2.创建虚拟环境3.设置命令走代理4.下载东西时ConnectionRefused5.通过ssh连接到另一台电脑6.Ctrl+C无法终止进程7.结束某个后台进程8.持久化安装9.桌面无反应10.装系统时缺少grub文件11.查看网络情况和本机IP12.令终端命令走代理13.释放缓存和swap14.Windows远程登录ubuntu桌面15.Sogou拼音皮肤安装不了
软件测试基础入门运筹帷幄小红花软件测试软件测试
一、基础概念什么是软件：控制计算机硬件的工具，操作系统软件、应用软件软件基本组成：客户端、服务器、数据库软件产生过程：需求构思-->需求文档-->UI/UE-->产品研发-->产品测试-->部署上线什么是软件测试：使用技术手段验证软件是否满足需求软件测试的目的：减少软件中的缺陷，保证软件质量；二、主流技术1、功能测试：执行测试用例2、自动化测试：通过工具或代码执行测试用例，场景：回归测试，新增功能
华为机试【机器人走迷宫】 weixin_41934659 华为机试 Java java 算法
标题：机器人走迷宫|时间限制：1秒|内存限制：65536K|语言限制：不限【机器人走迷宫】1、房间由XY的方格组成，例如下图为64的大小。每一个方格以坐标(x，y)描述。2、机器人固定从方格(0，0)出发，只能向东或者向北前进。出口固定为房间的最东北角，如下图的方格(5，3)。用例保证机器人可以从入口走到出口。3、房间有些方格是墙壁，如(4，1)，机器人不能经过那儿。4、有些地方是一旦到达就无法走
线程池创建及参数设置运筹帷幄小红花 java 开发语言后端
一、创建线程池以及线程池的各种参数分析：//不指定最大线程数，默认是Int的最大值ExecutorServiceexecutorService=Executors.newCachedThreadPool();executorService.submit(()->{System.out.println("新建线程池对象，执行第一个默认线程");});executorService.shutdown(
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带你飞]专题一简单搜索（大全）)