IOI 94 The Clock 详细的总结，从指数级复杂度到常数时间的优化

最新推荐文章于 2022-01-26 20:46:54 发布
最新推荐文章于 2022-01-26 20:46:54 发布
阅读量1.5k 收藏
点赞数
分类专栏： 算法竞赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzw_java/article/details/8167446
版权

原题

如果用bfs的话，也即，把操作顺序的先后考虑上的话，那么要注意用hash表来判重，用空间换时间。这个低效的方法也是能过的……

//hash表判重，dfs，从短到长按字典序扩展操作序列的长度 
/*
{
ID: lzwjava1
PROG: clocks
LANG: C++
}
*/
#include<cstdio>
#include<cstring>
#include<math.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
const int MaxState=500000;
int move[9][5]={{0,1,3,4},{0,1,2},{1,2,4,5},{0,3,6},
{1,3,4,5,7},{2,5,8},{3,4,6,7},{6,7,8},{4,5,7,8}};
int Nmove[9]={4,3,4,3,5,3,4,3,4};

typedef char state[9];
state st[MaxState];
char oper[MaxState];

bool isGoal(state a)
{
	for(int i=0;i<9;i++)
	  if(a[i]) return false;
  return true;
}

int fa[MaxState];

void doOper(state &a,int op)
{
	for(int i=0;i<Nmove[op];i++)
	  ++a[move[op][i]]%=4;
}

const int HashSize=10007;
int head[HashSize];
int next[MaxState];
int value[10];

int hash(int u)
{
	int t=0;
	for(int i=9;i>=0;i--)//mistook:i++,it should be"i--"
	  t+=value[9-i]*st[u][i];
  return t%HashSize;
}

bool tryToInsert(int u)
{
	int h=hash(u);
	int p=head[h];
	while(p!=-1)
	{
		if(memcmp(st[p],st[u],sizeof(st[p]))==0) return false;
		p=next[p];
	}
	next[u]=head[h];
	head[h]=u;
	return true;
}

void init_hash()
{
	memset(head,-1,sizeof(head));
	value[0]=1;
	for(int i=1;i<10;i++)
	  value[i]=value[i-1]*4;
}

int bfs()
{
	int front,rear;
	front=0;rear=1;
	fa[front]=-1;
	init_hash();
	while(front<rear)
	{
		state &u=st[front];
		if(isGoal(u)) return front;
		for(int i=0;i<9;i++)
		{
			state &v=st[rear];
			memcpy(v,u,sizeof(v));
			doOper(v,i);
			if(tryToInsert(rear))
			{
				fa[rear]=front;
				oper[rear++]=i;
			}
		}
		front++;
	}
}

void print_ans(int u)
{
	if(fa[u]==-1) return;
	print_ans(fa[u]);
	if(fa[u]!=0)  printf(" ");
  printf("%d",oper[u]+1);
}

int main()
{
  freopen("clocks.in","r",stdin);
  freopen("clocks.out","w",stdout);
  int i,j;
  for(i=0;i<9;i++)
  {
  	int t;
  	scanf("%d",&t);
  	st[0][i]=t/3%4;
  	//printf("%d\n",st[0][i]);
  }
  int ans=bfs();
  //printf("%d\n",ans);
  print_ans(ans);printf("\n");
  return 0;
}

/*
*/

事实上，操作的先后并不重要。用dfs降低空间复杂度，但最坏的时间复杂度是一样的。4^9。bfs找到解即返回。 

//dfs，无所谓操作的先后，而只记次数。遍历每一种可能的情况。 
/*
{
ID: lzwjava1
PROG: clocks
LANG: C++
}
*/
#include<cstdio>
#include<cstring>
#include<stdlib.h>
using namespace std;
const int MaxMove=27;
char move[9][9]={"ABDE","ABC","BCEF",//直接复制粘贴题目，在程序中来得到操作矩阵 
"ADG","BDEFH","CFI","DEGH","GHI","EFHI"};
int A[9];
int best[9];//最优答案 
int nbest;//最优答案的序列长度。先要最短，然后字典序最小 
int Clock[9][9];//Clock[i][j]为操作i一次j需要转过的刻钟的数目，3表示90°，0表示0°。只有这两种情况 
FILE *in,*out;

void cal_Clock()
{
	memset(Clock,0,sizeof(Clock));
	char *p;
	for(int i=0;i<9;i++)
		for(p=move[i];*p;p++)
		  Clock[i][*p-'A']=3;
}

bool is_ok(int *A)
{
	for(int i=0;i<9;i++)
	  if(A[i]!=12) return false;
  return true;
}

void solve(int *m,int cur)
{
	int i,j;
	if(cur==9)
	{
		if(is_ok(A))
		{
			int t=0;
			for(i=0;i<cur;i++) t+=m[i];
			if(!nbest || t<nbest)
			{
				memcpy(best,m,sizeof(best));
				nbest=t;
			}
		}
		return;//mistook:没加 
	}
	for(i=3;i>=0;i--)//先3个小序号的操作，这样可以得到最小字典序的方案 
	{
		for(j=0;j<i;j++)
			for(int k=0;k<9;k++)
			{
				A[k]+=Clock[cur][k];
				if(A[k]==15) A[k]=3;
				//fprintf(out,"A[k]=%d\n",A[k]);
			}
		m[cur]=i;
		solve(m,cur+1);
		for(j=0;j<i;j++)
			for(int k=0;k<9;k++)
			{
				A[k]-=Clock[cur][k];
				if(A[k]==0) A[k]=12;
			}
	}
}

void testClock()
{
	int i,j;
	for(i=0;i<9;i++,printf("\n"))
	  for(j=0;j<9;j++)
	  {
  		printf(" %d",Clock[i][j]);
  	}
}

int main()
{
	in=fopen("clocks.in","r");
	out=fopen("clocks.out","w");
	int i,j;
	for(i=0;i<9;i++) fscanf(in,"%d",&A[i]);
	//for(i=0;i<9;i++) printf("%d ",A[i]);
	int m[9];//m为次数数组，m[i]为执行操作i的次数 
	cal_Clock();
	//testClock();
	nbest=0;
	solve(m,0);
	bool first=true;
	for(i=0;i<9;i++)
	  if(best[i])
	  {
  		for(j=0;j<best[i];j++)
  		{
		  	if(!first) fprintf(out," ");
		  	else first=false;
		  	fprintf(out,"%d",i+1);
		  }
  	}
	fprintf(out,"\n");
	exit(0);
}

还可以通过打表得到最优解。这下可以优化到常数时间。

简便起见，把3,6,9,10表示成0,1,2,3。现在得到一个数组A，有9个操作，记第i个操作为O[i],O[i]让数组A中的某些数向前增加1，超过3则变为0。求一个最短的操作序列，让数组A的9个元素都变为0。

记V[j]为在最终的操作序列中执行O[j]的次数。

a[i][j]，表示仅让A[i]向前增1，而其它数都不变，所要执行O[j]的次数。得到矩阵a。矩阵a可以通过dfs的方法得到。

先求得a数组。改造一下上面的程序即可。

//dfs，巧妙得到a数组 
#include<cstdio>
#include<cstring>
#include<stdlib.h>
using namespace std;
const int MaxMove=27;
char move[9][9]={"ABDE","ABC","BCEF",
"ADG","BDEFH","CFI","DEGH","GHI","EFHI"};
int A[9];
int best[9];
int nbest;
int Clock[9][9];
FILE *in,*out;

void cal_Clock()
{
	memset(Clock,0,sizeof(Clock));
	char *p;
	for(int i=0;i<9;i++)
		for(p=move[i];*p;p++)
		  Clock[i][*p-'A']=3;
}

bool is_ok(int *A)
{
	for(int i=0;i<9;i++)
	  if(A[i]!=12) return false;
  return true;
}

void solve(int *m,int cur)
{
	int i,j;
	if(cur==9)
	{
		if(is_ok(A))
		{
			int t=0;
			for(i=0;i<cur;i++) t+=m[i];
			if(!nbest || t<nbest)
			{
				memcpy(best,m,sizeof(best));
				nbest=t;
			}
		}
		return;//mistook:没加 
	}
	for(i=3;i>=0;i--)
	{
		for(j=0;j<i;j++)
			for(int k=0;k<9;k++)
			{
				A[k]+=Clock[cur][k];
				if(A[k]==15) A[k]=3;
				//fprintf(out,"A[k]=%d\n",A[k]);
			}
		m[cur]=i;
		solve(m,cur+1);
		for(j=0;j<i;j++)
			for(int k=0;k<9;k++)
			{
				A[k]-=Clock[cur][k];
				if(A[k]==0) A[k]=12;
			}
	}
}

void testClock()
{
	int i,j;
	for(i=0;i<9;i++,printf("\n"))
	  for(j=0;j<9;j++)
	  {
  		printf(" %d",Clock[i][j]);
  	}
}

void work()
{
	//in=fopen("clocks.in","r");
	int i,j;
	//for(i=0;i<9;i++) printf("%d ",A[i]);
	int m[9];
	//testClock();
	nbest=0;
	solve(m,0);
	bool first=true;
	fprintf(out,"{%d",best[0]);
	for(i=1;i<9;i++)
	  fprintf(out,",%d",best[i]);
	fprintf(out,"},\n");
}

int main()
{
	out=fopen("a.out","w");
	int i,j;
	for(i=0;i<9;i++) A[i]=12;
	cal_Clock();
	for(i=0;i<9;i++)
	{
		A[i]=9;
		work();//得到尽让钟i转过90度的最优序列
		A[i]=12;
	}
	exit(0);
}
接下来，神代码出现了： 

//dfs下得到预处理数组。情况有限， 
/*
{
ID: lzwjava1
PROG: clocks
LANG: C++
}
*/
#include<cstdio>
#include<cstring>
int a[9][9]={
{3,3,3,3,3,2,3,2,0},
{2,3,2,3,2,3,1,0,1},
{3,3,3,2,3,3,0,2,3},
{2,3,1,3,2,0,2,3,1},
{2,3,2,3,1,3,2,3,2},
{1,3,2,0,2,3,1,3,2},
{3,2,0,3,3,2,3,3,3},
{1,0,1,3,2,3,2,3,2},
{0,2,3,2,3,3,3,3,3}
};

int main()
{
	freopen("clocks.in","r",stdin);
	freopen("clocks.out","w",stdout);
	int v[9];//v[i]表示操作i的执行次数 
	memset(v,0,sizeof(v));
	int i,j,k;
	for(i=0;i<9;i++)
	{
		scanf("%d",&k);
		for(j=0;j<9;j++)//计算把第i个钟的k变为12 v数组的变化。 
		  v[j]=(v[j]+a[i][j]*(12-k)/3)%4;//转一次，要执行j操作a[i][j]次 
	} 
	bool first=true;
	for(i=0;i<9;i++)
	  if(v[i])
	  {
  		for(j=0;j<v[i];j++)
  		{
		  	if(first) first=false;
  		  else printf(" ");
  		  printf("%d",i+1);
		  }	  
  	}
	printf("\n");
	return 0;
}

如果不是很理解，见：

Lucian Boca submitted a constant time solution

You can precalculate a matrix a as following:

a[i][0],a[i][1],....,a[i][8] is the number of moves '1','2','3',...'9' necessarly to move ONLY clock i (where 0 < i <= 8 - there are 9 clocks: 0=A, 1=B, ... 8=I) 90 degrees clockwise. So, you have the matrix:

int a[9][9]= { {3,3,3,3,3,2,3,2,0},
               {2,3,2,3,2,3,1,0,1},
               {3,3,3,2,3,3,0,2,3},
               {2,3,1,3,2,0,2,3,1},
               {2,3,2,3,1,3,2,3,2},
               {1,3,2,0,2,3,1,3,2},
               {3,2,0,3,3,2,3,3,3},
               {1,0,1,3,2,3,2,3,2},
               {0,2,3,2,3,3,3,3,3} };

That means: to move ONLY the clock 0 (clock A) 90 degrees clockwise you have to do {3,3,3,3,3,2,3,2,0}, 3 moves of type 1, three moves of type 2, ..., 2 moves of type 8, 0 moves of type 9, etc.

To move ONLY the clock 8 (clock I), you have to do the moves {0,2,3,2,3,3,3,3,3}: 0 moves of type 1, 2 moves of type 2... 3 moves of type 9....

That's it! You count in a vector v[9] how many moves of each type you have to do, and the results will be modulo 4 (%4 - 5 moves of any type have the same effect 1 move has). 


lzw_java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[IOI 1994]数字三角形
songyu005615的博客
04-13 558
数字三角形总时间限制: 1000ms 内存限制: 65536kB 描述 7 3 8 8 1 0 2 7 4 44 5 2 6 5 (图1)图1给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。 输入
常数优化的一些技巧
weixin_30502157的博客
07-19 158
一.STL 原则上手写要比用STL快，不过有些确实难打··· map和set直接用就好，都是基于红黑树实现（根本不会打），效率已经足够高（当然不惧码量的巨佬也可以手打） #include<cstdio> #include<cstdlib> using namespace std; #define L tree[x].l #define R tree[x...
常数优化
weixin_30699741的博客
01-26 266
虽然大部分的题都不会卡常数，但是万一卡常还是很恶心的，让我们一起来看看常数优化吧~ （蒟蒻太蒟了，可能无法覆盖到所有常数优化，请见谅~） register&inline 电脑CPU有一个高速缓存器，速度非常快，但占用内存小，一个变量加上register后，这个变量的存放位置就会在高速缓存器里。一般用于频繁修改的变量（如循环中的变量） 如： for(register in...
算法复杂度及常数优化
weixin_43192587的博客
10-06 466
各种
时间复杂度（学习总结）
weixin_45720714的博客
01-26 3172
什么是时间复杂度？时间复杂度是用来干什么？ 时间复杂度是一个函数，用来定性描述算法的运行时间。 假设算法的问题规模为n，那么操作单元数量便用函数f(n)来表示，随着数据规模n的增大，算法执行时间的增长率和f(n)的增长率相同，这称作为算法的渐近时间复杂度，简称时间复杂度，记为 O(f(n))。 在软件开发中，时间复杂度方便开发者估算当前程序运行的一般时间。 数据规模对时间复杂度有什么影响？ 从下图中可以看出不同算法的时间复杂度在不同数据输入规模下...
The Clocks（DFS）
Simone chou...
12-19 134
The ClocksIOI'94 - Day 2 Consider nine clocks arranged in a 3x3 array thusly: |-------| |-------| |-------| | | | | | | | |---O | |---O | | O |...
ioi 2020 题目
04-11
- **设计算法**：根据分析结果，设计高效的算法，考虑时间和空间复杂度。 - **编写代码**：将算法转化为代码，注意代码的可读性和效率。 - **测试验证**：使用提供的样例测试代码，确保正确性，必要时可以使用边界...
IOI国家集训队论文集
11-17
包括IOI中国国家集训队从1999年到2017年的论文 部分目录： 国家集训队1999论文集 陈宏：《数据结构的选择与算法效率——从IOI98试题PICTURE谈起》 来煜坤：《把握本质，灵活运用——动态规划的深入探讨》 齐鑫：...
IOI.ZIP_IOI_all IOI problems_download ioi proble_ioi 2002 soluti
最新发布
09-19
3. **复杂度分析**：理解并计算算法的时间复杂度和空间复杂度，这是评估解决方案效率的关键。 4. **编程语言**：通常IOI会使用C++、Python或Pascal等语言，通过阅读代码可以学习不同语言的编程技巧。 5. **问题建模*...
IOI2021集训日程.pdf
11-25
IOI2021集训日程 IOI2021集训日程是指2021年国际奥林匹克信息学竞赛（IOI）的国家集训队集中培训日程。该日程于2021年12月7日至12月12日在北京市海淀区中关村北大街126号举行。 该日程的主要内容包括报到、开幕式...
如何计算时间复杂度
热门推荐
firefly_2002的专栏
09-23 32万+
一、概念 时间复杂度是总运算次数表达式中受n的变化影响最大的那一项(不含系数) 比如：一般总运算次数表达式类似于这样： a*2^n+b*n^3+c*n^2+d*n*lg(n)+e*n+f a ！ =0时，时间复杂度就是O(2^n); a=0,bO(n^3); a,b=0,cO(n^2)依此类推 eg: (1) for(i=1;i //循环了n*n次，当然是O(n^2)
初学数据结构
TGYYS的博客
03-31 882
数据结构分类与类型 1.数据结构分类 2.数据类型 数据类型的分类类似于离散数学中的分类 算法 1.算法的特性 在《计算机科学导论》中我们学过，算法有着以下特性： 2.怎么计算效率？ 事前分析估算法 我们都知道二重循环要花费的时间一定比两个一重循环花的时间久，类似于这样的判断得出的结论就是事前分析估算法。 事后统计方法 通过同一计算机对不同程序所花费的时间进行对比，从而得出结论的方法就是事后...
ElGamal 算法思考
qq_29185043的博客
09-17 2651
前驱知识： 离散对数问题 离散对数 百度百科介绍： 在整数中，离散对数（英语：Discrete logarithm）是一种基于同余运算和原根的一种对数运算。而在实数中对数的定义 logba是指对于给定的a和b，有一个数x，使得bx=a。相同地在任何群G中可为所有整数k定义一个幂数为bx，而离散对数logba是指使得bx=a的整数k。[2] 离散对数在一些特殊情况下可以快速计算。然而，...
时间复杂度数量级分析
weixin_30784945的博客
12-03 1599
“大O记法”：在这种描述中使用的基本参数是n，即问题实例的规模，把复杂性或运行时间表达为n的函数。 注意：“O”表示量级(order)，比如说“二分检索是O(logn)的”,也就是说它需要“通过logn量级的步骤去检索一个规模为n的数组”记法O ( f(n) )表示当n增大时，运行时间至多将以正比于f(n)的速度增长。 这种渐进估计对算法的理...
算法的常数级--对数级-线性级
gsh1075035316的博客
08-10 3575
当重复执行的次数,就是问题的规模很大的时候就有很大区别了. 最好的算法就是常数阶的.无论问题规模多大执行时间不变. 对数阶就是 log a N .执行时间随执行次数呈对数增长 线性阶的次之.执行时间随问题规模增长呈正比例增长 运行时间随着问题规模增大的增长速度：指数级别 > 立方级别 > 平方级别 >> 线性对数级别 > 线性级别 >> 对数级别 > 常数级别 对数的底数和增长的数量级无关（因为不同的底数仅相当于一个常数因子），所以我们在说明对数级别时一般使用
求割点与桥
weixin_30344795的博客
08-21 79
在学习了刘汝佳大大的蓝书后有点体会，特来小结一下. 割点：对于无向图G，如果删除某个点u后，连通分量数目增加，称u为图的割点. 桥：对于无向图G，如果删除某条边(u,v)后，连通分量数目增加，称(u,v)为图的桥. 先说说怎么求割点吧，我们可以先想怎么暴力求解：把每一个点删除一次，然后dfs看连通分量的数目的变化，不过这样复杂度O(n(n + m)),能不能优化呢？...
The Famous Clock
标哥
10-06 618
The Famous Clock 时间限制：1000 ms  |  内存限制：65535 KB 难度：1 描述 Mr. B, Mr. G and Mr. M are now in Warsaw, Poland, for the 2012’s ACM-ICPC World Finals Contest. They’ve decided to take a 5 hours training
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值