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

 自描述序列

标题：自描述序列

小明在研究一个序列，叫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<Long> list = new ArrayList<Long>();
		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)<i+1){
				j++;
			}
			list.add(j+list.get(i));
			i++;
		}
		
		long m = 0;//n
		int n = 1;//G(n)
		long b = 0;
		long c = 0;
		long k = 0;//结果
		while(true){
			m++;
			long w = list.get(n);//G(n)对应的 最大 n
			if(m>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<Long> list = new ArrayList<Long>();
		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))<a){
			if(list.get(j)<i){
				j++;
			}
			list.add(j+list.get((i-1)));
			i++;
		}
		System.out.println(list.size()-1);
		
	}
}