蓝桥杯-第九届决赛—— 自描述序列

 自描述序列

标题:自描述序列

小明在研究一个序列,叫Golomb自描述序列,不妨将其记作{G(n)}。这个序列有2个很有趣的性质:

1. 对于任意正整数n,n在整个序列中恰好出现G(n)次。
2. 这个序列是不下降的。

以下是{G(n)}的前几项:

n    1    2    3    4    5    6    7    8    9    10    11    12    13
G(n)    1    2    2    3    3    4    4    4    5    5    5    6    6

给定一个整数n,你能帮小明算出G(n)的值吗?

输入
----
一个整数n。  

对于30%的数据,1 <= n <= 1000000  
对于70%的数据,1 <= n <= 1000000000  
对于100%的数据,1 <= n <= 2000000000000000  

输出
----
一个整数G(n)


【样例输入】
13

【样例输出】
6

资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗  < 1000ms


请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。

所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。

 思路:下面一段代码可以通过100%数据,是第二段代码优化后的(利用反函数)。

2000000000000000  对应的结果为   3438257305

根据他的前1000000项可以计算出所有数据。

首先保存一下他的反函数到list集合中

然后(n-1)*G(n-1)+n*G(n)+...依次类推可以得到他的范围

然后比较在他范围内再计算出他对应的G(n)。

   假如是6,1+2*2+2*3==11>6>1*1+2*2==5 也就是说6对应的G(n)大于1+2==3小于1+2+2==5

(6-5)/4==0 然后让5加上除完之后剩余的数(也就是在此基础上往后移几个数)

(6-5)%4!=0?3+1:3(如果除不尽的时候也就是有余数,那就在此基础上加1)

所以n=6对应的G(n)就是4

解析在注释中...

import java.util.ArrayList;
import java.util.Scanner;
//2000000000000000   3438257305
public class Main {
 
	public static void main(String[] args) {
		
		Scanner in = new Scanner(System.in);
		long a = in.nextLong();
		ArrayList list = new ArrayList();
		list.add((long) 0);
		list.add((long) 1);
		list.add((long) 3);
		if(a==1){
			System.out.println(1);
			return;
		}
		int i=2;
		int j = 2;
		while(list.get(i)<1000000){
			if(list.get(j)w){//在最大范围内他们各自的个数
				n++;//G(n)
			}
			b+=n*m;//累加
			c = c+n;
			if(b>=a){//如果累加到比所求的数字大的话,结束循环,结果就在c-n到c这个范围内
				if(b>a){//如果不够,c-n到c这个范围内
					//(a-(b-n*m))给的数字减去累加后的前一项的值,就是这个段内的数字除以m,就是后面那个值,加上前一个的结果,就是k了
					k = ((c-n)+((a-(b-n*m))/m));
					if((a-(b-n*m))%m!=0){//如果除不尽了,就再加一,除尽就不用加了。
						k++;
					}
				}else{//如果刚好到,那就是c了
					k = c;
				}
				break;
			}
//			System.out.println("n:"+m+" G(n):"+n+" b:"+b+" c:"+c);
		}
		System.out.println(k);
	}
	
}

 

思路:因为对于任意正整数n,n在整个序列中恰好出现G(n)次。

所以呢可以依次类推,看第二张表,为了提高效率,用的反函数。

由G(n)在n区间找到对应的G(n)然后在前一个的基础上相加,就得到了下一个G(n)对应的最大n。

下面一段代码可以通过70%的数据,也就是1000000000以内。再大的话就会超时了。

不考虑时间,再大的话list数组也放不了那么多数据。最大到196016964920结果是11451102

n 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1000000000 ... 100000000000 ...
G(n) 1 2 2 3 3 4 4 4 5 5 5 6 6 6 6 438744 ... 7554625 ...
G(n) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 ...
n 1 3 5 8 11 15 19 23 28 33 38 44 50 56 62 69 76 83 ...
import java.util.ArrayList;
import java.util.Scanner;
//2000000000000000
public class Main2 {

	public static void main(String[] args) {
//		1 2 3 4 5  6  7  8  9  10 11 12 13 ... 673365     7554625      i
//		1 3 5 8 11 15 19 23 28 33 38 44 50 ... 2000004511 100000007919 list.get(i)
		Scanner in = new Scanner(System.in);
		long a = in.nextLong();
		ArrayList list = new ArrayList();
		list.add((long) 0);
		list.add((long) 1);
		list.add((long) 3);
		if(a==1){
			System.out.println(1);
			return;
		}
		Integer i=3;
		Integer j = 2;
		while(list.get((i-1))

 

你可能感兴趣的:(算法-蓝桥杯,蓝桥杯历届试题)