【题解】Kathy函数 [BZOJ1223] [P2235] [HNOI2002]

【题解】Kathy函数 [BZOJ1223] [P2235] [HNOI2002]

---

这几疯狂刷了数位\(dp\)的题，到这道题时被卡了一天，一看大佬的讲解发现居然是求回文数╮(╯_╰)╭

感觉被大佬狠狠地蹂蹑了一番。。。

废话到此结束，进入正题：

满足\(f(n)=n\)的\(n\)在二进制的形式下一定是一个回文数

例如:

\(f(1)=1\) (\(1\))

\(f(3)=3\) (\(11\))

\(f(5)=5\) (\(101\))

\(f(7)=7\) (\(111\))

至于为什么会有这个性质，这里就作证明(都懒得给自己的懒惰找借口了)

假设已经成功的证明了这个结论，那么问题就变成了在\([1,n]\)中找到符合二进制形式为回文数的总个数，这里我提供一种用\(dfs\)实现数位\(dp\)的思路

可以先写一下这道题（因为不需要高精）：

只需要输出区间内回文数的总个数

LightOJ1205

---

用\(dfs\)找回文数个数：

一：转进制

首先我们需要把\(n\)转化为二进制存储在一个数组\(num[lenn]\)中

二：DFS

\(dfs(st,pos,ok,limit)\)

记搜以及状态表示：

用一个数组记录已经搜过的地方，\(dp[pos][ok][st]\) 示已经选到了第\(pos\)位，前已经选好的是否满足回文\(ok\)，去前导\(0\)后共有\(st\)位，并且前面已选的并未全部达到上限（\(pos\)开始后面可以随意选\(0\)或\(1\)），此时的回文数总数。

\(limit\)表示前面已选的是否全达到上限，如果是，那么这一位的可以选的数的上限为\(num[pos]\)，否则可以随意选，\(ed=limit?num[pos]:1\)。

如果当前状态并未受限，且当前状态的\(dp\)值已经被记录，直接返回这个值

如何枚举递归

每当选了一个数\(i\)时， \(tmp[pos]=i\)。

(1) 如果前面都没选（即全是前\(0\)，\(st=pos\)），

\(ans+=dfs\)(\(st-1\),\(pos-1\),\(ok\),\(limit\)&&\(i==ed\))

(2) 如果前面选了（即\(st>pos\)）

1. 如果当前状态是回文数，且当前选的这位在\(st\)的后半段（即\(ok\)&&\(pos<=st/2\)），则\(okk=tmp[st-pos+1]==i\)
2. 否则 \(okk=ok\)。
   
   \(ans+=dfs\)(\(st\),\(pos-1\),\(okk\),\(limit\)&&\(i==ed\))

\(dfs\)边界

当\(pos==0\)（即已经选完了所有位）

如果满足回文数（即\(ok=1\)）且选了数（即并非全是\(0\)，\(st>0\)）\(return 1\)。

三.高精

推荐写结构体，用起来方便，不会的可以参考一下大佬的高精模板

最后附上代码：

#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
const int base = 1e8;
const int N = 20;
int aux[N << 3];
struct bigint {
    int s[N], l;
    void CL() { l = 0; memset(s, 0, sizeof(s)); }
    void pr()
    {
        printf("%d", s[l]);
        for (int i = l - 1; i; i--)
            printf("%08d", s[i]);
    }
    void re_l()
    {
        int i, x = 0, k = 1, L = 0, fl, o;
        char c = getchar();
        for (; c < '0' || c > '9'; c = getchar());
        for (; c >= '0' && c <= '9'; c = getchar())
        {
            if (!(L - 1) && !aux[L])
                L--;
            aux[++L] = c - '0';
        }
        CL();
        l = L / 8 + ((o = L % 8) > 0);
        for (i = 1; i <= o; i++)
            x = x * 10 + aux[i];
        if (o)
            s[l] = x;
        fl = !o ? l + 1 : l;
        for (i = o + 1, x = 0; i <= L; i++, k++)
        {
            x = x * 10 + aux[i];
            if (!(k ^ 8))
            {
                s[--fl] = x;
                x = k = 0;
            }
        }
        if (!l)
            l = 1;
    }
    ll toint()
    {
        ll x = 0;
        for (int i = l; i; i--)
            x = x * base + s[i];
        return x;
    }
    bigint operator = (int b)
    {
        CL();
        do
        {
            s[++l] = b % base;
            b /= base;
        } while (b > 0);
        return *this;
    }
    bigint operator = (ll b)
    {
        CL();
        do
        {
            s[++l] = b % base;
            b /= base;
        } while (b > 0);
        return *this;
    }
    bigint operator + (const int &b)
    {
        bigint c = *this;
        ll x = b;
        for (int i = 1; i <= l && x; i++)
        {
            x = x + c.s[i];
            c.s[i] = x % base;
            x /= base;
        }
        if(x)c.s[++c.l] = x;
        return c;
    }
    bigint operator + (const ll &b)
    {
        bigint c = *this;
        ll x = b;
        for (int i = 1; i <= l && x; i++)
        {
            x = x + c.s[i];
            c.s[i] = x % base;
            x /= base;
        }
        if (x)
            c.s[++c.l] = x;
        return c;
    }
    bigint operator + (bigint &b)
    {
        if (b.l < 3)
            return *this + b.toint();
        bigint c;
        ll x = 0;
        int k = l < b.l ? b.l : l;
        c.CL();
        c.l = k;
        for (int i = 1; i <= k; i++)
        {
            x = x + s[i] + b.s[i];
            c.s[i] = x % base;
            x /= base;
        }
        if (x)
            c.s[++c.l] = x;
        return c;
    }
    bigint operator / (const int &b)
    {
        bigint c;
        ll x = 0;
        c.CL();
        for (int i = l; i; i--)
        {
            c.s[i] = (x * base + s[i]) / b;
            x = (x * base + s[i]) % b;
        }
        for (c.l = l; !c.s[c.l] && c.l > 1; c.l--);
        return c;
    }
    bigint operator % (const int &b)
    {
        bigint c;
        ll x = 0;
        c.CL();
        for (int i = l; i; i--)
            x = (x * base + s[i]) % b;
        return c = x;
    }
    bool operator > (const bigint &b) const
    {
        if (l ^ b.l)
            return l > b.l;
        for (int i = l; i; i--)
            if (s[i] ^ b.s[i])
                return s[i] > b.s[i];
        return false;
    }
    bigint operator += (bigint &b)
    {
        return *this = *this + b;
    }
    bool operator > (int b) const{
        bigint c;return *this > (c = b);
    }
};
//以上皆为高精度部分

bigint a;
int num[350],tmp[350];bigint dp[350][2][350];
bool pan[350][2][350];
inline bigint dfs(int st,int len,int ok,bool limit){
    bigint ans,pp;ans=0;pp=0;
	if(len<1){//边界
    	if(ok&&st>0)ans=1;
    	return ans;
    }
    if(!limit&&pan[len][ok][st])return dp[len][ok][st];//返回所记录的值
    int ed=limit?num[len]:1;//处理枚举上限
    for(int i=0;i<=ed;i++){
        tmp[len]=i;//记录每次选的数，方便判断是否满足回文
        if(st==len&&!i)pp=dfs(st-1,len-1,ok,limit&&i==ed),ans+=pp;//如果一直都没选数
        else pp=dfs(st,len-1,(ok&&len<=st/2)?tmp[st-len+1]==i:ok,limit&&i==ed),ans+=pp;//如果选了数
	}
    if(!limit)dp[len][ok][st]=ans,pan[len][ok][st]=1;//记录
    return ans;
}
int main(){
    a.re_l();ll Lenn=0;
    while(a>0){num[++Lenn]=(a%2).toint();a=(a/2);}//转成2进制存起来
    bigint ans=dfs(Lenn,Lenn,1,1);
    ans.pr();
    return 0;
}