POJ3074-Sudoku
题目大意：
将9*9的数独完成并输出
解题思路：
用数组row[0]~row[8]来存储1~9行中每一行当前填放数字的状态，列和小九宫格类似。其次在dfs过程中选择可填放的位置时要找当前可选择数最少的格子放，这样可以极大地减少搜索的分支
代码：
#include <iostream>
#include <cstring>
#include <cstdio>
#include <stdlib.h>
#include <algorithm>
#define ll long long
using namespace std;
const int inf=0x3f3f3f3f;
const int N=9;
const int NN=3;
int row[N]; // 记录放置数的状态
int line[N];
int ge[NN][NN];
int a[N][N];
int ones[1<<N]; // 二进制1的数量
int nums[1<<N]; // 数位转数字 100 -->3
int kk;
inline int lowbit(int x) // 得到二进制最后一个1及其后面的0组成的数
{
return x & (-x);
}
void init()
{
kk=(1<<N)-1;
for(int i=0; i<N; i++)
nums[1<<i]=i+1;
for(int i=0; i<1<<N; i++)
for(int j=i; j; j-=lowbit(j))
ones[i]++;
}
inline int get(int y, int x) // 得到可放置的数
{
return (row[y]^kk)&(line[x]^kk)&(ge[y/NN][x/NN]^kk);
}
bool dfs(int num)
{
if(!num)
{
for(int i=0; i<N; i++)
{
for(int j=0; j<N; j++)
cout<<a[i][j];
}
cout<<endl;
return true;
}
int xx,yy;
int maxl=inf;
for(int i=0; i<N; i++) // 找出可放置数最少的格子
for(int j=0; j<N; j++)
{
if(a[i][j])
continue;
int t=get(i,j);
if(ones[t]<maxl)
{
maxl=ones[t];
yy=i,xx=j;
}
}
for(int i=get(yy,xx); i; i-=lowbit(i))
{
int t=lowbit(i);
ge[yy/NN][xx/NN]+=t;
row[yy]+=t;
line[xx]+=t;
a[yy][xx]=nums[t];
if(dfs(num-1))
return true;
ge[yy/NN][xx/NN]-=t;
row[yy]-=t;
line[xx]-=t;
a[yy][xx]=0;
}
return false;
}
int main()
{
string s;
init();
while(cin>>s)
{
if(s[0]=='e')
break;
memset(row,0,sizeof(row));
memset(line,0,sizeof(line));
memset(ge,0,sizeof(ge));
int num=0;
for(int i=0,k=0; i<N; i++)
for(int j=0; j<N; j++,k++)
{
if(s[k]!='.')
{
a[i][j]=s[k]-'0';
ge[i/NN][j/NN]+=1<<(a[i][j]-1);
row[i]+=1<<(a[i][j]-1);
line[j]+=1<<(a[i][j]-1);
}
else
{
a[i][j]=0;
num++;
}
}
dfs(num);
}
return 0;
}
POJ2676-Sudoku
题目大意：
与前一题基本一样，稍作修改即可
解题思路：
略
代码：
略
POJ1088-滑雪
题目大意：
给定二维矩阵，求最长的单调递减路线的长度
解题思路：
记忆化dfs,vis[i][j]表示从当前位置开始的最长递减长度
代码：
#include <iostream>
#include <cstring>
#include <cstdio>
#include <stdlib.h>
#include <algorithm>
#define ll long long
#define rd(x) scanf("%d",&x)
#define rd2(x,y) scanf("%d%d",&x,&y)
#define rd3(x,y,z) scanf("%d%d%d",&x,&y,&z)
using namespace std;
const int inf=0x3f3f3f3f;
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
int n,m;
const int N=105;
int a[N][N];
int vis[N][N];
int dfs(int y, int x)
{
if(vis[y][x])
return vis[y][x];
int t=0;
for(int i=0; i<4; i++)
{
int fy=y+dir[i][0];
int fx=x+dir[i][1];
if(fy<1 || fy>n || fx<1 || fx>m || a[fy][fx]>=a[y][x])
continue;
t=max(t,dfs(fy, fx));
}
vis[y][x]=t+1;
return vis[y][x];
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
while(cin>>n>>m)
{
memset(vis,0,sizeof(vis));
for(int i=1; i<=n; i++)
for(int j=1; j<=m; j++)
cin>>a[i][j];
int ans=0;
for(int i=1; i<=n; i++)
for(int j=1; j<=m; j++)
ans=max(ans,dfs(i,j));
cout<<ans<<endl;
}
return 0;
}LightOJ1139-8 Puzzle
题目大意：
求解8数码问题的最少步数
解题思路：
bfs预处理所有可能出现的状态，状态可以用string来存储
代码：
#include <iostream>
#include <cstdio>
#include <map>
#include <queue>
using namespace std;
const int N=100;
map<string,int>hah,vis;
string aim;
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
int a[3][3];
int aa[10];
typedef struct
{
int y;
int x;
string s;
}node;
inline string fun()
{
string s;
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
s+='0'+a[i][j];
return s;
}
queue<node>que;
void bfs()
{
while(que.size())
{
node t=que.front();
que.pop();
for(int i=0; i<4; i++)
{
int fy=t.y+dir[i][0];
int fx=t.x+dir[i][1];
if(fy<0 || fy>2 || fx<0 || fx>2)
continue;
string now=t.s;
now[t.y*3+t.x]=now[fy*3+fx];
now[fy*3+fx]='0';
if(vis[now])
continue;
vis[now]=1;
hah[now]=hah[t.s]+1;
que.push({fy,fx,now});
}
}
}
int main()
{
int T;
string t="123456780";
hah[t]=0;
vis[t]=1;
que.push({2,2,t});
bfs();
cin>>T;
for(int kk=1; kk<=T; kk++)
{
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
scanf("%d",&a[i][j]);
cout<<"Case "<<kk<<": ";
string t=fun();
if(vis[t])
cout<<hah[t]<<endl;
else
cout<<"impossible"<<endl;
}
return 0;
}
POJ1190-生日蛋糕
题目大意：
给定体积n和层数m，求制作一个上面每层的半径和高度都比下面一层小的蛋糕的最小表面积（上下表面只计算其中一个面积）
解题思路：
枚举最底层蛋糕的半径然后进行dfs，可以提前把剩余层数的体积下限先用数组存起来，有一个知识点就是在体积一定时，表面积最小的情况就是圆柱体(把剩余层数的半径都看作相同)，利用这个可以将dfs进行大量的剪枝
代码：
#include <iostream>
#include <cstring>
#include <cmath>
using namespace std;
const int inf=0x3f3f3f3f;
int n,m,ans;
int min_v[21];
void dfs(int flag, int rr, int hh, int v, int s)
{
if(flag==0)
{
if(v==n && ans>s)
ans=s;
return;
}
if(2*(n-v)/rr+s>=ans || min_v[flag]+v>n) // s=2*Pi*r*h v=Pi*r*r*h --> s=2*v/r
return;
for(int i=rr-1; i>=flag; i--)
{
if(flag==m)
s=i*i;
for(int j=hh-1; j>=flag; j--)
dfs(flag-1, i, j, v+i*i*j, s+2*i*j);
}
}
int main()
{
min_v[0]=0;
for(int i=1; i<=20; i++)
min_v[i]=i*i*i+min_v[i-1];
while(cin>>n>>m)
{
ans=inf;
dfs(m,(int)sqrt(n)+1,n+1,0,0); // 从底部开始搜索
cout<<ans<<endl;
}
return 0;
}POJ1579-Function Run Fun
题目大意：
根据指定条件返回相应的答案
解题思路：
记忆化dfs
代码：
#include <iostream>
#include <cstring>
#include <cstdio>
#include <stdlib.h>
#include <algorithm>
#define rd(x) scanf("%d",&x)
#define rd2(x,y) scanf("%d%d",&x,&y)
#define rd3(x,y,z) scanf("%d%d%d",&x,&y,&z)
using namespace std;
const int inf=0x3f3f3f3f;
int vis[21][21][21];
int dfs(int a, int b, int c)
{
if(a<=0 || b<=0 || c<=0)
return 1;
if(a>20 || b>20 || c>20)
return dfs(20,20,20);
if(vis[a][b][c])
return vis[a][b][c];
int t;
if(a<b && b<c)
t=dfs(a, b, c-1)+dfs(a, b-1, c-1)-dfs(a, b-1, c);
else
t=dfs(a-1, b, c)+dfs(a-1, b-1, c)+dfs(a-1, b, c-1)-dfs(a-1, b-1, c-1);
vis[a][b][c]=t;
return t;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(vis,0,sizeof(vis));
dfs(20,20,20);
int a,b,c;
while(cin>>a>>b>>c)
{
if(a==-1 && b==-1 && c==-1)
break;
cout<<"w("<<a<<", "<<b<<", "<<c<<") = "<<dfs(a,b,c)<<endl;
}
return 0;
}POJ3253-Fence Repair
题目大意：
用一根长木棍制作一些指定长度的短木棍，每次切割都会累计等同于当前木棍长度的权值
解题思路：
很容易想到先要将较长的短木棍切出来，使得剩余的木棍平均长度都尽可能短，但是每次切割的长度并不好确定，我们可以采用逆向思维，将切割木棍转化成拼接木棍，每次都找出最短的两根进行拼接，使用优先队列即可完成
代码：
#include <iostream>
#include <queue>
#include <vector>
#define ll long long
using namespace std;
const int inf=0x3f3f3f3f;
priority_queue<int, vector<int>, greater<int> >que;
int main()
{
int n,x;
ll sum=0;
cin>>n;
while(n--)
{
cin>>x;
que.push(x);
}
while(que.size()>=2) // 逆向思维
{
int a=que.top();
que.pop();
a+=que.top();
que.pop();
sum+=a;
que.push(a);
}
cout<<sum<<endl;
return 0;
}POJ1011-Sticks
题目大意：
将一些短棍拼接复原成长度都相同的长棍，求长棍可能的最短长度是多少
解题思路：
枚举长棍的长度进行dfs
代码：
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
int n,kk;
int a[70];
int vis[70];
bool dfs(int flag, int now, int start)
{
if(flag==0)
return now==0;
if(now==0)
return dfs(flag, kk, n);
for(int i=start; i>=1; i--) // 从大到小
{
if(!vis[i] && a[i]<=now)
{
vis[i]=1;
if(dfs(flag-1, now-a[i], i-1))
return true;
vis[i]=0;
if(a[i]==now || now==kk) // 需要注意的剪枝
break;
while(i>1 && a[i]==a[i-1]) // 跳过相同长度的棍子
i--;
}
}
return false;
}
int main()
{
while(cin>>n && n)
{
int sum=0;
for(int i=1; i<=n; i++)
{
cin>>a[i];
sum+=a[i];
}
sort(a+1, a+1+n);
for(kk=a[n]; kk<=sum; kk++)
{
if(sum%kk)
continue;
memset(vis,0,sizeof(vis));
if(dfs(n, kk, n))
{
cout<<kk<<endl;
break;
}
}
}
return 0;
}51Nod1832-先序遍历与后序遍历
题目大意：
给定二叉树的先序遍历与后序遍历，求该二叉树可能的结构种数
解题思路：
当且仅当二叉树的一个节点只有一个子树时，先序遍历与后序遍历无法明确的将该二叉树表示出来，因此方案数*2
代码：
#include <iostream> /// 先序遍历+后序遍历求方案数
#include <cstring>
#include <cstdio>
#include <map>
using namespace std;
const int inf=0x3f3f3f3f;
const int N=10005;
const int mod=1e6;
int a[N],b[N],node_cnt,en,n;
map<int,int>hahb;
int t[510];
// 2的10000次方有3011位数
void fun()
{
b[0]=-1;
for(int i=1; i<n; i++)
if(b[hahb[a[i]]-1]==a[i+1]) //先序的右边节点与后序的左边节点相同则只有一颗子树,方案数*2
node_cnt++;
en=t[1]=1;
while(node_cnt--) // 高精度乘
{
for(int i=1; i<=en; i++) // 每一位乘2
t[i]<<=1;
for(int i=1; i<=en; i++)
{
t[i+1]+=t[i]/mod;
t[i]%=mod;
}
if(t[en+1])
en++;
}
printf("%d",t[en]);
for(int i=en-1; i>=1; i--)
printf("%06d",t[i]);
}
int main()
{
while(~scanf("%d",&n))
{
memset(t,0,sizeof(t));
hahb.clear();
node_cnt=0;
for(int i=1; i<=n; i++)
rd(a[i]);
for(int i=1; i<=n; i++)
{
rd(b[i]);
hahb[b[i]]=i; // 标记在哪个位置
}
fun();
}
return 0;
}
826
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
