POJ 3373--Changing Digits

最新推荐文章于 2018-09-22 20:19:20 发布

fu_ding1991

最新推荐文章于 2018-09-22 20:19:20 发布

阅读量454

点赞数

分类专栏：动态规划 BFS/DFS POJ 文章标签： poj 算法算法导论动态规划

本文链接：https://blog.csdn.net/dingzuoer/article/details/41410151

版权

POJ 同时被 3 个专栏收录

66 篇文章 0 订阅

订阅专栏

BFS/DFS

32 篇文章 0 订阅

订阅专栏

动态规划

29 篇文章 0 订阅

订阅专栏

题意：给定一个一百位的的数n以及一个小于等于n的数k，问最少需要改变多少位使新的数能被k整除，在改变位数相同的情况下又要改变后的数尽量小。

题解：本题有DP和搜索两种解法。

一、DP算法：因为题目给出的k只有5位，所以可以以取模后的数当做状态进行递归求解。

设dp[i][j]为前i位模为j的最小改变位数，易知前i+1位的状态仅仅是由dp[i][j]决定，满足最优子结构.
若第i+1位改为m得转移方程：new_state = (j+m*10^i)%k，dp[i+1][new_state] = min{dp[i+1][new_state]，dp[i][j]+1}，若m仍然和n[i+1]一致，则dp[i][j]不用加一。
为了回溯最优的字符串，还需要利用另一个数组minInt[i][j]记录前i位模为j时需要改变最小位数，且改变位数相同时改变后的值尽量小的第i位的值。

二、搜索算法：

最开始采用BFS暴搜，利用Hash判重，TLE。参考CSDN小优中的搜索技巧，既能满足题设，又不需要判重。每次当需要搜索从第i位到最高位时，我们先搜索比n小的数，再搜索比n大的数。
利用BFS达到模为0时即可输出，因为其显然是改变位数最小的，且每次都是从改变后的较小数到较大数。因为要保存字符串耗内存较多。
利用DFS且加入一定的DP数组vis[pos][modRe]，若从pos到最高位，改变j位不能达到模为modRe，则再减少改变位数显然也是不能达到。

DP：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define INF 0x7F

class solve
{
private:
    char *n;
    int len;
    int k;
    char** minChangeNum;
    char** minInt;
    int* modList[10];
public:
    solve(char* s):n(s)
    {
        len = strlen(n);
        scanf("%d",&k);
        getchar();
        generateModList();
        DP();
    }
    ~solve()
    {
        delete[] n;
        delete[] minChangeNum;
        delete[] minInt;
        for(int i = 0;i < 10;i++)
        {
            delete[] modList[i];
        }
    }
    int generateModList();
    int DP();
};

int solve::generateModList()
{
    int i,j;
    for(i = 0;i <= 9;i++)
    {
        modList[i] = new int[len];
        modList[i][0] = i%k;
        for(j = 1;j < len;j++)
        {
            modList[i][j] = (modList[i][j-1]*10)%k;
        }
    }
    return 0;
}

int solve::DP()
{
    int i,j,m;
    int new_state;
    int tmpNum;
    minChangeNum = new char*[len+1];
    minInt = new char*[len+1];
    for(i = 0;i <= len;i++)
    {
        minChangeNum[i] = new char[k];
        minInt[i] = new char[k];
        memset(minInt[i],INF,sizeof(char)*k);
        memset(minChangeNum[i],INF,sizeof(char)*k);
    }
    i = (n[len-1]-'0')%k;
    minChangeNum[1][i] = 0;
    minInt[1][i] = n[len-1]-'0';
    for(m = 0;m <= 9;m++)
    {
        j = m%k;
        if(j != i)
        {
            minChangeNum[1][j] = 1;
            minInt[1][j] = min((int)minInt[1][j],m);
        }
    }
    for(i = 2;i <= len;i++)
    {
        for(j = 0;j < k;j++)
        {
            if(minChangeNum[i-1][j] == INF)
                continue;
            for(m = 0;m <= 9;m++)
            {
                if(i == len&&m == 0)
                    continue;
                new_state = (j+modList[m][i-1])%k;
                tmpNum = minChangeNum[i-1][j];
                if(n[len-i] != m+'0')
                {
                    tmpNum++;
                }
                if(minChangeNum[i][new_state] > tmpNum)
                {
                    minChangeNum[i][new_state] = tmpNum;
                    minInt[i][new_state] = m;
                }
                else if(minChangeNum[i][new_state] == tmpNum&&minInt[i][new_state] > m)
                {
                    minInt[i][new_state] = m;
                }
            }
        }
    }
    j = 0;
    for(i = len;i >= 1;i--)
    {
        printf("%c",minInt[i][j]+'0');
        j = (j-modList[minInt[i][j]][i-1]+k)%k;
    }
    printf("\n");
    return 0;
}

int main()
{
    char s[105];
    while(gets(s))
    {
        solve poj_3373(s);
    }
    return 0;
}

BFS：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

class solve
{
private:
    char *n;
    int len;
    int k;
    char vis[105][10005];
    int* modList[10];
public:
    solve(char* s):n(s)
    {
        len = strlen(n);
        scanf("%d",&k);
        getchar();
        generateModList();
        BFS();
    }
    int generateModList();
    int BFS();
};

class node
{
public:
    char pos;
    int modRe;
    char* ans;
};

int solve::BFS()
{
    int i,j,m;
    node now,next;
    memset(vis,0,sizeof(vis));
    now.pos = 0;
    now.modRe = 0;
    for(i = 0;i < len;i++)
    {
        n[i] = n[i]-'0';
        now.modRe = (now.modRe+modList[n[i]][len-i-1])%k;
    }
    if(now.modRe == 0)
    {
        for(m = 0;m < len;m++)
        printf("%c",n[m]+'0');
        printf("\n");
        return 0;
    }
    now.ans = n;
    queue<node> q;
    q.push(now);
    vis[0][now.modRe] = 1;
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        for(i = now.pos;i < len;i++)
        {
            next.pos = i+1;
            for(j = 0;j < n[i];j++)
            {
                if(i == 0&&j == 0&&len != 1)
                {
                    continue;
                }
                next.modRe = (now.modRe-modList[n[i]][len-1-i]+modList[j][len-1-i]+k)%k;
                if(!vis[next.pos][next.modRe])
                {
                    next.ans = new char[len];
                    memcpy(next.ans,now.ans,sizeof(char)*(len));
                    next.ans[i] = j;
                    if(next.modRe == 0)
                    {
                        for(m = 0;m < len;m++)
                            printf("%c",next.ans[m]+'0');
                        printf("\n");
                        return 0;
                    }
                    q.push(next);
                    vis[next.pos][next.modRe] = 1;
                }
            }
        }
        for(i = len-1;i >= now.pos;i--)
        {
            next.pos = i+1;
            for(j = n[i]+1;j < 10;j++)
            {
                next.modRe = (now.modRe-modList[n[i]][len-1-i]+modList[j][len-1-i]+k)%k;
                if(!vis[next.pos][next.modRe])
                {
                    next.ans = new char[len];
                    memcpy(next.ans,now.ans,sizeof(char)*(len));
                    next.ans[i] = j;
                    if(next.modRe == 0)
                    {
                        for(m = 0;m < len;m++)
                            printf("%c",next.ans[m]+'0');
                        printf("\n");
                        return 0;
                    }
                    q.push(next);
                    vis[next.pos][next.modRe] = 1;
                }
            }
        }
    }
    return 0;
}

int solve::generateModList()
{
    int i,j;
    for(i = 0;i <= 9;i++)
    {
        modList[i] = new int[len];
        modList[i][0] = i%k;
        for(j = 1;j < len;j++)
        {
            modList[i][j] = (modList[i][j-1]*10)%k;
        }
    }
    return 0;
}

int main()
{
    char s[105];
    while(gets(s))
    {
        solve poj_3373(s);
    }
    return 0;
}

DFS:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

class solve
{
private:
    char *n;
    int len;
    int k;
    char vis[105][10005];
    int* modList[10];
    int initRe;
    char* ans;
public:
    solve(char* s):n(s)
    {
        len = strlen(n);
        scanf("%d",&k);
        getchar();
        generateModList();
        initRe = 0;
        ans = new char[len+1];
        memcpy(ans,n,sizeof(char)*(len+1));
        for(int i = 0;i < len;i++)
        {
            n[i] = n[i]-'0';
            initRe = (initRe+modList[n[i]][len-i-1])%k;
        }
        memset(vis,0,sizeof(vis));
        for(int i = 0;i <= len;i++)
        {
            if(DFS(0,initRe,i))
            {
                printf("%s\n",ans);
                break;
            }
        }
    }
    int generateModList();
    int DFS(char pos,int modRe,char changeNum);
};

int solve::DFS(char pos,int modRe,char changeNum)
{
    if(modRe == 0)
        return 1;
    if(changeNum == 0||vis[pos][modRe] >= changeNum)
        return 0;
    int i,j;
    int newRe;
    for(i = pos;i < len;i++)
    {
        for(j = 0;j < n[i];j++)
        {
            if(i == 0&&j == 0&&len != 1)
                continue;
            newRe = (modRe-modList[n[i]][len-1-i]+modList[j][len-1-i]+k)%k;
            ans[i] = j+'0';
            if(DFS(i+1,newRe,changeNum-1))
                return 1;
        }
        ans[i] = n[i]+'0';
    }
    for(i = len-1;i >= pos;i--)
    {
        for(j = n[i]+1;j < 10;j++)
        {
            newRe = (modRe-modList[n[i]][len-1-i]+modList[j][len-1-i]+k)%k;
            ans[i] = j+'0';
            if(DFS(i+1,newRe,changeNum-1))
                return 1;
        }
        ans[i] = n[i]+'0';
    }
    vis[pos][modRe] = changeNum;
    return 0;
}

int solve::generateModList()
{
    int i,j;
    for(i = 0;i <= 9;i++)
    {
        modList[i] = new int[len];
        modList[i][0] = i%k;
        for(j = 1;j < len;j++)
        {
            modList[i][j] = (modList[i][j-1]*10)%k;
        }
    }
    return 0;
}

int main()
{
    char s[105];
    while(gets(s))
    {
        solve poj_3373(s);
    }
    return 0;
}