2015 UESTC Winter Training 中的简单搜索

最新推荐文章于 2020-03-02 17:33:09 发布
最新推荐文章于 2020-03-02 17:33:09 发布
阅读量668 收藏
点赞数
分类专栏： 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013007900/article/details/43951331
版权


uvalive 4997

简答搜索

先将中心求出来，并且染上无关色，染色之后若有地方未染色，则说明不行

然后再用回溯法染色

//      whn6325689
//		Mr.Phoebe
//		http://blog.csdn.net/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")


using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))
#define MID(x,y) (x+((y-x)>>1))
#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
const int DX[] = {-2, -2, -2, -1, -1, -1, -1,  0, 0,  1,  1, 1, 1,  2, 2, 2};
const int DY[] = {-1,  0,  1, -2, -1,  1,  2, -2, 2, -2, -1, 1, 2, -1, 0, 1};

int n;
char ma[20][20];
struct Node
{
    int x, y;
    char col;
    Node(){}
    Node(const int &x,const int &y,const char col='\0'):x(x),y(y),col(col){}
} a[400];
int tot;
bool flag;

bool isCenter(int x, int y)
{
    if(ma[x][y] != '.') return 0;
    for(int k=0; k<4; k++)
    {
        int xx=x+dx[k];
        int yy=y+dy[k];
        if(xx<1 || xx>n || yy<1 || yy>n)
            return 0;
        if(ma[xx][yy]!='.')
            return 0;
    }
    return 1;
}
void change(int x,int y,char ch)
{
    ma[x][y]=ch;
    for(int k=0; k<4; k++)
        ma[x+dx[k]][y+dy[k]]=ch;
}

bool isfull()
{
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            if(ma[i][j]=='.')
                return 0;
    return 1;
}

bool check(int x,int y,char ch)
{
    for(int k=0; k<16; k++)
    {
        int xx=x+DX[k];
        int yy=y+DY[k];
        if(xx<1 || xx>n || yy<1 || yy>n) continue;
        if(ma[xx][yy]==ch) return 0;
    }
    return 1;
}

void dfs(int x)
{
    if(flag) return;
    if(x>tot)
    {
        flag=1;
        return;
    }
    for(char ch='B'; ch<='D'; ch++)
    {
        if(!check(a[x].x,a[x].y,ch))  continue;
        a[x].col=ch;
        change(a[x].x,a[x].y,ch);
        dfs(x+1);
        if(flag)
            return;
    }
    change(a[x].x,a[x].y,'q');
}

int main()
{
    int T,cas=1;
    read(T);
    while(T--)
    {
        read(n);
        printf("Case %d:",cas++);
        for(int i=1; i<=n; i++)
            scanf("%s", ma[i]+1);
        tot=0;
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(isCenter(i, j))
                {
                    a[++tot]=Node(i,j);
                    change(i,j,'q');
                }
        if(!isfull())
            puts(" Not Possible!");
        else
        {
            flag=0;
            dfs(1);
            if(!flag)
                puts(" Not Possible!");
            else
            {
                putchar('\n');
                for(int i=1; i<=n; i++)
                    printf("%s\n",ma[i]+1);
            }
        }
    }
    return 0;
}




uvalive 5066

bfs求最短路

然后用背包求答案

//      whn6325689
//		Mr.Phoebe
//		http://blog.csdn.net/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")


using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))
#define MID(x,y) (x+((y-x)>>1))
#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

struct Node
{
    int x,y,z;
    int step;
    Node(const int& x=0,const int& y=0,const int& z=0,const int& step=0):x(x),y(y),z(z),step(step){}
};
struct P
{
    int ti,sc;
}pp[111];
const int dx[]={0,0,0,0,1,-1},dy[]={1,-1,0,0,0,0},dz[]={0,0,1,-1,0,0};
char ma[15][111][111];
bool vis[15][111][111];
int dp[10010],p[15][111][111];
int l,h,w,n,s,tot;
Node st;
queue<Node> q;

bool in(int x,int y,int z)
{
    if (x>=1 && x<=l && y>=1 && y<=h && z>=1 && z<=w && ma[x][y][z]!='X' && vis[x][y][z]==0)
		return 1;
    return 0;
}

void bfs()
{
	int x,y,z;
	CLR(vis,0);
	while(!q.empty())	q.pop();
	q.push(st);
    vis[st.x][st.y][st.z]=1;
    tot=0;
    while(!q.empty())
    {
    	Node now=q.front();
    	q.pop();
    	if(ma[now.x][now.y][now.z]=='#')
		{
            pp[++tot].sc=p[now.x][now.y][now.z];
            pp[tot].ti=now.step*3;
        }
    	for(int i=0;i<4;i++)
    	{
            x=now.x+dx[i];
            y=now.y+dy[i];
            z=now.z+dz[i];
            if(in(x,y,z))
			{
                q.push(Node(x,y,z,now.step+1));
                vis[x][y][z]=1;
            }
        }
        if(ma[now.x][now.y][now.z]=='U')
		{
            x=now.x+dx[4];
            y=now.y+dy[4];
            z=now.z+dz[4];
            if(in(x,y,z))
			{
                q.push(Node(x,y,z,now.step+1));
                vis[x][y][z]=1;
            }
        }
        if(ma[now.x][now.y][now.z]=='D')
		{
            x=now.x+dx[5];
            y=now.y+dy[5];
            z=now.z+dz[5];
            if(in(x,y,z))
			{
  				q.push(Node(x,y,z,now.step+1));
                vis[x][y][z]=1;
            }
        }	
    }
	
}

int main()
{
//	freopen("data.txt","r",stdin);
	int T;
	scanf("%d",&T);
	while(T--)
	{
		CLR(dp,0);CLR(pp,0);
  		scanf("%d %d %d %d %d",&l,&h,&w,&n,&s);
		for(int i=1;i<=l;i++)
            for(int j=1;j<=h;j++)
			{
                scanf("%s",ma[i][j]+1);
                for(int k=1;k<=w;k++)
                    if(ma[i][j][k]=='S')
						st=Node(i,j,k,0);                    
            }
        for(int i=1,fl,hh,ww,sc;i<=n;i++)
		{
            scanf("%d %d %d %d",&fl,&hh,&ww,&sc);
            p[fl][hh][ww]=sc;
            ma[fl][hh][ww]='#';
        }
/*
        for(int i=1;i<=l;i++)
        	for(int j=1;j<=h;j++)
        		printf("%s\n",ma[i][j]+1);
*/
		bfs();
		for(int i=1;i<=tot;i++)
            for(int j=s;j>=pp[i].ti;j--)
                dp[j]=max(dp[j],dp[j-pp[i].ti]+pp[i].sc);
        printf("%d\n",dp[s]);
	}
	return 0;
}


HDU 4166

bfs暴搜

本来想用A*的，后来想起来还要求路径

//      whn6325689
//		Mr.Phoebe
//		http://blog.csdn.net/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")


using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))
#define MID(x,y) (x+((y-x)>>1))
#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

int n,m,mod;

const int dir[4][2]={-1,0,0,1,1,0,0,-1};

struct Node
{
	int x,y,dir;
	int step;
	Node(const int& x=0,const int& y=0,const int& dir=0,const int& step=0):x(x),y(y),dir(dir),step(step){}
	bool operator == (const Node& b) const
	{
		if(x==b.x && y==b.y)	return true;
		return false;
	}
	void output()
	{
		write(x),putchar(' '),write(y),putchar(' '),write(dir),putchar('\n');
	}
};

int dis[1010][1010][4],num[1010][1010][4];
char ma[1010][1010],ss[22];
int idx[200],flag,ans;

bool in(int x,int y)
{
	return x>=0 && x<n && y>=0 && y<m && ma[x][y]=='.';
}

void bfs(Node s,Node t)
{
	queue<Node > q;
	int f[3];
	while(!q.empty())	q.pop();
	dis[s.x][s.y][s.dir]=0;
	num[s.x][s.y][s.dir]=1;
	q.push(s);
	while(!q.empty())
	{
		Node now=q.front();q.pop();
		int x=now.x,y=now.y;
		f[0]=now.dir;f[1]=(f[0]+1)%4;f[2]=(f[0]+3)%4;
		int xx=x+dir[f[0]][0];
		int yy=y+dir[f[0]][1];
		if(now==t)
		{
			flag=1;
			for(int i=0;i<4;i++)
				if(dis[x][y][i]==now.step)
					ans=(ans+num[x][y][i])%mod; 
			break;
		}
		if(in(xx,yy))
		{
			if(dis[xx][yy][f[0]]>now.step+1)
			{
				dis[xx][yy][f[0]]=now.step+1;
				num[xx][yy][f[0]]=num[x][y][f[0]];
				q.push(Node(xx,yy,f[0],dis[xx][yy][f[0]]));
			}
			else if(dis[xx][yy][f[0]]==now.step+1)
				num[xx][yy][f[0]]=(num[xx][yy][f[0]]+num[x][y][f[0]])%mod;
		}
		for(int i=1;i<=2;i++)
		{
			if(dis[x][y][f[i]]>now.step+1)
			{
				dis[x][y][f[i]]=now.step+1;
				num[x][y][f[i]]=num[x][y][f[0]];
				q.push(Node(x,y,f[i],dis[x][y][f[i]]));
			}
			else if(dis[x][y][f[i]]==now.step+1)
				num[x][y][f[i]]=(num[x][y][f[i]]+num[x][y][f[0]])%mod;
		}
	} 
}

int main()
{
//	freopen("data.txt","r",stdin);
	int cas=1;
	idx['N']=0;idx['E']=1;
    idx['S']=2;idx['W']=3;
    while(read(n)&&read(m)&&read(mod)&&(mod))
    {
    	CLR(dis,INF);CLR(num,0);
    	Node s,t;flag=ans=0;
    	for(int i=0;i<n;i++)
    		scanf("%s",ma[i]);
   		read(s.x),read(s.y);
   		read(t.x),read(t.y);
   		scanf("%s",ss);
   		s.dir=idx[ss[0]];s.step=0;
   		bfs(s,t);
   		if(!flag)
   			ans=-1;
		printf("Case %d: %d %d\n",cas++,mod,ans);
    }
    return 0;
}


SuPhoebe
关注
专栏目录
2018 UESTC Training for Dynamic Programming - J 如何才能保留那些美好
skysys的研究小屋
06-24 297
Content 进入命运石之门的辉子，看到的是数量巨大的记忆碎片，深知很难把这些美好记忆都带回去给 Sakura 的辉子感到深深的无力。 一共有n块记忆碎片，每块记忆碎片的体积为 V_iV i ​ , 每块的美好值为 W_iW i ​ ，辉子现在有一个可以装最大体积为m的魔法包，辉子想知道自己最多可以带多大的美好值的记忆碎片回去给 Sakura。 Standard ...
2015 UESTC Winter Training #9
Mr.Phoebe的专栏
03-04 707
传送门 这场比赛是2010东京区域赛的题目，只做了几题简单的题目 Aizu 1305 Membership Management 题意：给你几个部门的人，一个部门可能包含于另一个部门之下 问：第一个部门有多少人 用map给每个部门编号，然后set数组存每个部门人名，然后用dfs搜索答案 // whn6325689 // Mr.Phoebe // http://bl
2015 UESTC Winter Training #10【Northeastern Europe 2009】
weixin_30500289的博客
02-04 56
2015 UESTC Winter Training #10 Northeastern Europe 2009 最近集训都不在状态啊，嘛，上午一直在练车，比赛时也是刚吃过午饭，状态不好也难免，下次比赛提前吃饭休息一会儿吧。。 一开始卡在B题，后来发现是题意理解错了，没有看见above，就是不可以回到原点，WA了5发也是够可惜的。 顺利地过了G题之后，就卡在了C题上，要T成doge了T...
2015 UESTC Winter Training #7【2010-2011 Petrozavodsk Winter Training Camp, Saratov State U Contest】...
weixin_30885111的博客
01-22 206
2015 UESTC Winter Training #7 2010-2011 Petrozavodsk Winter Training Camp, Saratov State U Contest 据说这套题写出3题就是金牌水平了。。。 Problem D. Group Stage 足球比赛，现在有n（2<= n <=100）支球队。要从中选拔m（1<= m ...
2015 UESTC Winter Training #8【The 2011 Rocky Mountain Regional Contest】
weixin_30726161的博客
01-27 99
2015 UESTC Winter Training #8 The 2011 Rocky Mountain Regional Contest Regionals 2011>>North America - Rocky Mountain 开始时貌似是UVAlive挂了，无论交什么都WA，后来转战HDU 这次水题比较多，其中B题据说有更加高级的方法。 G题WA了两发，才...
2015 UESTC Winter Training #4【Regionals 2008 :: Asia - Tehran】
weixin_30690833的博客
01-19 73
2015 UESTC Winter Training #4 Regionals 2008::Asia - Tehran 比赛开始时电脑死活也连不上WIFI，导致花了近1个小时才解决_(:зゝ∠)_ 未完成：B E F G H I A -String LD 给n（<=100）个互不相同的字符串（最长为100），然后进行stringld操作，就是每次操作把各个字...
2015 UESTC Winter Training #6【Regionals 2010 >> North America - Rocky Mountain】
weixin_30655569的博客
01-21 142
2015 UESTC Winter Training #6 Regionals 2010>>North America - Rocky Mountain A -Parenthesis 给一个长度不多于1000的表达式，只包含小写字母，加法运算，省略乘号的乘法运算和括号，输出去掉多余括号的表达式 括号匹配可以使用栈操作，只有两种情况可以去掉这一对括号： 左...
UESTC 2020 Winter Training #1 Basic Data Structure【Animal Transport】
mxYlulu的博客
03-02 304
题意 四种物品，nnn个，每个有自己的起点和终点，相邻物品不能放一起。 卡车按顺序访问地点，要求求出运输物品为iii的时候，去的最大地点标号。 不能跳过任何地点。 题解 易知，1、31、31、3物品放一块，2、42、42、4放一块。 如果只放同一种不冲突的话，如何求呢？ 我们可以发现的是，最大地点标号为pospospos时，显然包含所有r≤posr \leq posr≤pos的物品。 也就是，我们...
UESTC 2019 Summer Training #1 Div.2
mxYlulu的博客
07-10 299
菜鸡不配拥有姓名 AAA 题意：每次可以将一个大正方形切成四个小正方形，并且保证切割之后从左下角到右上角走过的正方形都是同样大小的。 参考：https://blog.csdn.net/Tiw_Air_Op1721/article/details/84454136 这个题解写的比较详细。 主要的意思是： 我们最终要实现的形态是这样的： 最左和左上的正方形不断切割保证同时切割，剩下的可以随意切割。 ...
UESTC_Can You Help God Wu CDOJ 582
weixin_30820151的博客
04-25 102
There is a boy named God Wu in UESTC ACM team. One day he is asked to finish a task. The task is that he has to paint a wall as the given pattern. The wall can be represented as a2×ngrid and each ...
UESTC summer training A 【树链剖分 模板】
skysys的研究小屋
08-24 362
#include #include #include #include #include using namespace std; typedef long long ll; void read(int& x) { x = 0; char c = getchar(); int flag = 1; while(c'9') { c = getchar(); if(c=='-')fla
2014 UESTC Training for Dynamic Programming
Commence,的艰苦历程
06-02 597
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define LL long long #define PI 3.1415926
UESTC Training for Data Structures——K
蛤蛤~
05-02 813
Problem  K Problem Description A math instructor is too lazy to grade a question in the exam papers in which students are supposed to produce a complicated formula for the question asked. Students
UESTC Training for Data Structures(总结)
蛤蛤~
05-02 849
UESTC Training for Data Structures     第一次的专题讲座总算是AK了。数据结构，多么熟悉的字眼，最怕的就是线段树了，但偏偏这套题中 13 道就有 5 道线段树！恼火。     题目分布：     线段树：D (扫描线求矩形面积并)             G (并查集+线段树)             H、I、M (线段树的基本操作)     树状
4和7是一个幸运数字
Mr.Phoebe的专栏
04-04 6950
一个比较有趣的面试题 题意： 仅由4和7组成的十进制数字被称为幸运数字，如，4，7，44，47。 那么仅由幸运数字乘积得到的数字为超级幸运数字，如，28 = 4 * 7。 现在给你两个数字表示上下限，让你求这段区间内有多少个超级幸运数字。总共有1000组查询，上下限最多到1012101210^{12}。 思路： 第一想法是容斥搞一下，但是其实非常难，因为除了爆搜很难去构造出仅由幸运数字...
BUPT 2014新生暑假个人排位赛11
Mr.Phoebe的专栏
08-06 1522
488. 小妹妹个数
Poj 1112 Team Them Up!
Mr.Phoebe的专栏
08-12 1123
首先分析这道题目，题目给出的是一个有向图，即如果有A认识B，但不一定有B认识A。但是在所分配的组里面，任意两个人都要互相认识。 1、 先读入数据建立有向图，然后对这个有向图进行处理，如果两个点之间的边是单向边，就认为两个点之间无边（因为这两个人不互相认识），对于两个点间的双向边，即建立一条无向边（这两个人互相认识），这样就可以把一个有向图转化为一个无向图。 2、 将这个无向图转化为它的
Gym 100339A Bike Roads
Mr.Phoebe的专栏
02-11 1106
Andrew Stankevich Contest 23 Petrozavodsk, February 1, 2007 Problem A. Bike Roads Andrew lives at countryside. The area he lives at has two bike roads, each of which has the form of acircle
HDU 5025 Saving Tang Monk
Mr.Phoebe的专栏
09-20 1013
//By LH #include #include #include #include using namespace std; const int dx[4] = {0, 1, 0, -1}; const int dy[4] = {1, 0, -1, 0}; int n, m, sx, sy, ex, ey, ans; char a[102][102]; bool v[102][102][1
互联网络程序设计 uestc
最新发布
11-01
UESTC则是我国的一所著名高校——电子科技大学。 互联网络程序设计 uestc包含了两个主要的方面：互联网络和程序设计。互联网络是指将多个计算机网络通过通信链路互相连接起来，实现信息共享和资源共享的网络系统。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值