第N个lunlun数！

定义：
lunlun数：是一个所有相邻位数的差不超过1的整数
例如 1234 5678 454 343 321 54567 等等等

题目大意：现在给你一个整数 N，要求输出第 N个lunlun数
其中 N<=10000

分析：这个题如果使用暴力的做法枚举每一个数字，第10000个lunlun已经超过了10位，时间上卡不过去。

现在在这里分享一个AC的做法：
首先我们先大致找一下lunlun数的规律

如果 abc是一个3位lunlun数
如果 a取3，那么b只能取 2 3 4，然后再分别根据b取2 3 4进行讨论，确定c的取数，就可以确定一个以3开头的三位lunlun数的所有可能的取数情况！

所以说此时 对于lunlun数的组成情况，是可以找到一定规律的
一个百位数是3的lunlun数，其实际的组成数量=十位是2的两位数lunlun数数量+十位是3的两位数lunlun数数量+十位数是4的两位数lunlun数数量。

其中十位是2的两位lunlun数不就是 23 22 21三个吗
其实就是 个位是1的一位数数量+个位是2的一位数数量+个位是3的一位数数量

此时状态转移
对于一个 l位，r开头的lunlun数，其可能的组成数量

dp[l][r]=dp[l-1][r-1]+dp[l-1][r]+dp[l-1][r+1]
所以对所有的个位数，即dp[1][r] (0<=r<=9)设置为1,然后进行上述的状态转移
即可对数量进行分层

我们给lunlun数进行这样的操作，就是想知道lunlun数的分布规律
现在给出一个整数N
我们可以不断的对他进行 N-dp[l][r]的操作，直到他小于等于dp[l][r]时停止
此时我们就确定了当前 第N个lunlun数的大致位置了！（第N个lunlun数是一个l位的数，并且首数字是r的整数）。

确定了大致的位置之后，我们就知道了第N个lunlun数字是一个以r开头的数字，那么接下来，我就要继续通过刚才的方式进一步锁定第N个lunlun数字的位置，如果 n<=dp[l][r-1],说明他目前的等级不足够超过 dp[l][r-1].那 么他的下一个数字一定是r-1,如果 n>dp[l][[r-1],再判断当前N的数量等级是否比 dp[l][r]大，如果比dp[l][r]大，那么下一位数字一定是 r+1,否则 下一位数字就是 r!

这样下去，我们就又确定了一位数字，然后 l–,重复上面的操作，一位一位的确认，把数字的每一位存进队列，最后一位一位的输出即使最终答案！

思路总结：
第一步：根据lunlun数字的分布规律给lunlun数字进行数量上的分层
第二部，用整数n逐步的跟每一层上的数量比较，逐步一位一位确定答案的位置！

实际的操作例子
例：N=30;
30-dp[1][1]=29;
29-dp[1][2]=28;
…
22-dp[1][9]=21;
21-dp[2][1]=18;
18-dp[2][2]=15;
15-dp[2][3]=12;
…
3-dp[2][7]=0;
n<=dp[2][7]
此时确定了 第30个lunlun数的大致位置 为2位数，7开头
由于是一个两位数，第一位是7，现在只需要再确定1位即可完成任务！
我们继续拿上述操作进一步确认
3 > dp[1][6]=1
3-dp[1][6]=2;
排除掉了数字76
2 > dp[1][7]=1;
2-dp[1][7]=1;
排除掉了数字77；
1<=dp[1][8];
说明下一位数字就是8
所以第30个lunlun数字是78！

#include<bits/stdc++.h>
using namespace std 
const int N=110;
int dp[N][N];
int main()
{
    int n;
    cin>>n;
    for (int i=0;i<=9;i++) //0-9！ 
	dp[1][i]=1; 
    for (int i=2;i<=10;i++)
        for (int j=0;j<=9;j++)
            dp[i][j]=dp[i-1][j]+dp[i-1][j-1]+dp[i-1][j+1];
    int l=0,r=0,flag=0;
    for (int i=1;i<=10;i++) 
	{
        for (int j=1;j<=9;j++) 
		{
            if(n<=dp[i][j])
			{
                l=i,r=j,flag=1;
                break;
            }
            n-=dp[i][j]; 
        }
        if(flag==1)break;
    }
    l--;
    queue<int> ans;
    ans.push(r); 
    while(l!=0)
	{
        if(n<=dp[l][r-1])
		{
            r--;
            ans.push(r);
        }
		else
		{
            n-=dp[l][r-1];
            if(n<=dp[l][r])
            {
			ans.push(r);
			}
			else
			{
                n-=dp[l][r];
                r++;

                ans.push(r);
            }
        }
        l--;
    }
    while(!ans.empty())
	{
	cout<<ans.front();
	ans.pop();
	} 
    return 0 ;
}

2021/6/13