【RMQ】A Magic Lamp

A Magic Lamp

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2327    Accepted Submission(s): 923

Problem Description

Kiki likes traveling. One day she finds a magic lamp, unfortunately the genie in the lamp is not so kind. Kiki must answer a question, and then the genie will realize one of her dreams. 
The question is: give you an integer, you are allowed to delete exactly m digits. The left digits will form a new integer. You should make it minimum.
You are not allowed to change the order of the digits. Now can you help Kiki to realize her dream?

 

 

Input

There are several test cases.
Each test case will contain an integer you are given (which may at most contains 1000 digits.) and the integer m (if the integer contains n digits, m will not bigger then n). The given integer will not contain leading zero.

 

 

Output

For each case, output the minimum result you can get in one line.
If the result contains leading zero, ignore it. 

 

 

Sample Input

178543 4

1000001 1

100001 2

12345 2

54321 2

 

 

Sample Output

13

1

0

123

321

 

题目大意：

　　输入一串数字，然后在输入K，问你如果在这串数字中去除K位，则这串数字的最小值是多少、

 

解法：

1.RMQ (真的没想到Orz,Orz,Orz....)

　　- -,如果没有想到该怎么用RMQ比较好，还是对RMQ的使用理解的不够深刻呀。。。

　　对于每次输入M长度的数字串，要去除K为，那么得出结果的数字串是否最多为M-K个数字。我们依次对区间[s1,E],取最小值,然后再从这次最小值的位置的下一位开始s1开始，第二次从区间[s2,E+1]中在取最小值，反复操作，直到第M-K次,取得区间[s(M-K) ,M]的最小值，每一次区间所取得的最小值为所组成的数字串为最优解。

 si为第i-1次所取得的最小值的下一个位置。s1的初始值为1，E的初始值为K+1，每取一次E++(保证结果的每一位数都为最小值，且顺序不会错乱。)。

代码：(2015.8.15)

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stack>
#define MAX 1010
using namespace std;
char Str[MAX];
char Min[MAX][11];
void Cread_ST(int N)
{
    for(int i=1;i<=N;i++)Min[i][0]=Str[i-1]-'0';
    int Len=(int)(log(N*1.0)/log(2.0));
    for(int j=1;j<=Len;j++){
        for(int i=1;i+(1<<j)-1<=N;i++){
            int TMD=i+(1<<(j-1));
            Min[i][j]=min(Min[i][j-1],Min[TMD][j-1]);
        }
    }
}
int RMQ(int a,int b)
{
    int K=(int)(log(b-a+1.0)/log(2.0));
    int TMD=b-(1<<K)+1;
    int MIN=min(Min[a][K],Min[TMD][K]);
    return MIN;
}
int main()
{
    int K,i,j,Len,Start,End,Zero,k;
    int Num;
    while(scanf(" %s %d",Str,&K)!=EOF)
    {
        Len=strlen(Str);
        Cread_ST(Len);
        k=Len-K;Start=1;Zero=1;End=K;
        if(k<=0){printf("0\n");continue;}
        while((k--)&&(Start<=Len)&&(End+1<=Len))
        {
            End++;
            Num=RMQ(Start,End);
            if(Num!=0)Zero=0;/*去除前导0*/
            if(!Zero)printf("%d",Num);
            for(j=Start;j<=End;j++)
            {
                if(Str[j-1]-'0'==Num)
                {Start=j+1;break;}
            }
        }
        if(Zero)printf("0");/*输入全部为0的情况*/
        putchar(10);
    }
    return 0;
}

 

2.贪心的策略的(第一反应想到的。。。)

　　对于每次去除数字，要使得这串数字最小，则首先考虑的是去除高位的数。

　　比如 xx87xx,的话，我们如果去除8的话，得到的是xx7xx,如果我们不去除8的话，则无论去除后面哪一位都是xx8xx,而且这个数肯定会大于xx7xx，所以我们可以考虑先把当前数字比下一位大的话，优先去除。总的来说，就是每次从高位往下，判断如果一个数比它下一个数大的话，则去除这个数可以得到最优解，每去除一次后，从头开始从新判断即可。

　　用数组做的话，每次去除一个数的话，不好操作，反而，用链表的话，则可以很好的实现这些功能，把数字一个一个链接起来。- -，自己闲的蛋疼，想到前向星是用头插法，自己也不太懂得用链表，然后就抱着试一试的态度，把前向星改成了链表，而且还是尾插法（想法很简单，不过链表实现起来，还是有些细节得注意的,Orz,Orz,Orz,....）。

代码：(2015.8.14)

#include <iostream>
#include <stdio.h>
#include <string.h>
#define MAX 1010
using namespace std;
char Num[MAX];
int Top;/*记录边的编号*/
struct edge{int P,TO,Next,Fa;}ID[MAX];
void Add_E(char x,char y)/*尾插法*/
{
    ID[Top-1].Next=Top;
    ID[Top].P=x-'0';
    ID[Top].TO=y-'0';
    ID[Top].Fa=Top-1;
    ID[Top++].Next=-1;
}
void Deal_Cread(int Len)/*初始化*/
{
    memset(ID,-1,sizeof(ID));Top=1;
}
void Deal_Link(int Len)
{
    for(int i=0,Max=Num[0]-'0',Max_S=1;i+1<Len;i++)
    {
        /*Max=Num[0]-'0';     去除前导0
        if(Max_S&&MAX==0)continue;
        else Max_S=0;*/
        if(i==0)    /*获取第一个非0字符*/
        {
            ID[Top].Fa=-1;/*头节点的祖先设置为-1*/
            ID[Top].P=Num[i]-'0';
            ID[Top].TO=Num[i+1]-'0';
            ID[Top++].Next=-1;
            Max_S=1;
        }
        else Add_E(Num[i],Num[i+1]);
    }ID[Top-1].Next=0;/*额外在尾部添加最后一个节点，方便操作*/
     ID[0].Fa=Top-1;ID[0].Next=-1;
     ID[0].P=Num[Len-1]-'0';ID[0].TO=9;
}
void Update(int i)
{
    if(ID[i].Fa==-1)Top=ID[i].Next;/*如果去除点为头结点则更新头结点编号*/
    ID[ID[i].Next].Fa=ID[i].Fa;
    if(ID[i].Fa!=-1)
    {
        ID[ID[i].Fa].Next=ID[i].Next;
        ID[ID[i].Fa].TO=ID[i].TO;
    }
}

void Deal_Del(int K)
{
    Top=1;/*头结点的编号*/
    while(K--)
    {
        int Sign,i;
        for(i=Top;i!=-1;i=ID[i].Next)
        {
            Sign=ID[i].Fa;/*记录最后一个节点的父亲节点*/
            if(ID[i].P>ID[i].TO){Update(i);break;}
        }/*如果没有找到符合条件的情况，删除最后一个字符*/
        if(i==-1)Update(ID[Sign].Next);
    }
}
void Deal_Put()
{
    int i,Sign;
    for(i=Top,Sign=0;i!=-1;i=ID[i].Next)
    {
        if(!Sign&&Sign<ID[i].P)
        {
            Sign=ID[i].P;
            printf("%d",ID[i].P);
        }
        else if(Sign)  printf("%d",ID[i].P);
    }
    if(!Sign)printf("0");
    putchar(10);
}
int main()
{
    int Len,K;
    while(scanf(" %s %d",Num,&K)!=EOF)
    {
        Len=strlen(Num);
        if(K>=Len){printf("0\n");continue;}
        Deal_Cread(Len);
        Deal_Link(Len);
        Deal_Del(K);
        Deal_Put();
    }
    return 0;
}

　PS:　如果不用链表的话，其实也可以直接用栈/队列来实现。