Leetcode刷题--贪心--去除重复字母

Leetcode刷题–贪心

leetcode 316 – 去除重复字母

题目描述（中等题）

给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证 返回结果的字典序最小（要求不能打乱其他字符的相对位置）。

示例 1：
输入：s = “bcabc”
输出：“abc”

示例 2：
输入：s = “cbacdcbc”
输出：“acdb”

思路：

思路1： 局部最优 ——> 全局最优 就是先找a,再找b …等等，先确定单个最小字母的位置，再依次确定较大字母的位置。
但是该思路走不通

思路2： 例如：s = “cbacdcbc” ，先找出所有的’c’，确定要保留哪个位置的’c’。但是无法确定，思路还是走不通。

思路3：看了题目相关标签，单调栈，去找了单调栈的概念（下文介绍），才有点思路。 将给定字符从前往后依次输入单调递增栈，当要对栈顶元素char1弹出时，要考虑给定的字符串后面是否还有char1一样的元素，若有则放心弹出，若无则不弹出，保留并将当前要入栈元素入栈。同时要入栈元素char2若在栈中已经存在，则跳过当前要入栈元素char2 ，执行下轮循环。
例子：s = “cbacdcbc” ，c入栈，接下来到b，b小于c，而我们是递增栈，所以要弹出c，但先判断后面是否还有c，后面确实有c，则弹出c，b入栈。接下来a同理，弹出b，入栈a。c和d满足递增栈，可入栈。接下来是c，但栈中已经有c，则跳过这个c。接下来是b，当前栈顶为d，理论上应该弹出这个较大的字符，但先判断后面是否还有d，后面没有d了，则保留d，并将b入栈。同理，后面的c删去。

代码如下：

//定义栈
type Stack struct{
    str1 string
    length int
}

func (this *Stack) Pop() {
    this.length-=1
}

func (this *Stack) Push(x byte) {
    if(len(this.str1)==this.length){
        this.str1 = this.str1+string(x)
    }else{
        runes := []rune(this.str1)   //字符串的单个元素不可改变
        runes[this.length] = rune(x)  //因此只能这样：使用[]byte或[]rune将字符串转换为可变的字节或字符切片，然后修改切片中的某个元素，再将切片转换回字符串。
        this.str1 = string(runes)
    }
    this.length+=1
}


func removeDuplicateLetters(s string) string {

    Stack1 := Stack{str1:"",length:0}
    for i:=0;i<len(s);i++{
        if Stack1.length==0{
            Stack1.Push(s[i])
            continue
        }


        //s[i]元素要入栈，先判断栈中是否已经存在与s[i]相同元素，有则跳过当前s[i],无则与栈顶元素比较，若小于栈顶元素x则还需考虑后面是否还有与x一样的元素，若有则放心弹出x并将s[i]入栈，若无则不弹出，保留并将当前要入栈元素入栈。
        if strings.Contains(Stack1.str1,string(s[i])){
            continue
        }else if s[i]>Stack1.str1[Stack1.length-1]{
            Stack1.Push(s[i])
        }
        m:=0
        for Stack1.length-1-m>=0&&s[i]<Stack1.str1[Stack1.length-1-m]{ //这里就是下面介绍的单调栈的逻辑
            x:=Stack1.str1[Stack1.length-1-m]
            if m==0{
                if strings.Contains(s[i+1:],string(x)){
                    Stack1.Pop()
                    Stack1.Push(s[i])
                    m=1
                }else{
                    Stack1.Push(s[i])
                    break;
                }
            }else{
                if strings.Contains(s[i+1:],string(x)){
                    Stack1.Pop()
                    Stack1.Pop()
                    Stack1.Push(s[i])
                }else{
                    break
                }
            }
        }
      
    }
    return Stack1.str1[0:Stack1.length]


}

单调栈：单调栈中存放的数据应该是有序的，所以单调栈也分为单调递增栈和单调递减栈。现在有一组数10，3，7，4，12。从左到右依次入栈，则如果栈为空或入栈元素值小于栈顶元素值，则入栈；否则，如果入栈则会破坏栈的单调性，则需要把比入栈元素小的元素全部出栈。单调递减的栈反之。

• 10入栈时，栈为空，直接入栈，栈内元素为10。
• 3入栈时，栈顶元素10比3大，则入栈，栈内元素为10，3。
• 7入栈时，栈顶元素3比7小，则栈顶元素出栈，此时栈顶元素为10，比7大，则7入栈，栈内元素为10，7。
• 4入栈时，栈顶元素7比4大，则入栈，栈内元素为10，7，4。
• 12入栈时，栈顶元素4比12小，4出栈，此时栈顶元素为7，仍比12小，栈顶元素7继续出栈，此时栈顶元素为10，仍比12小，10出栈，此时栈为空，12入栈，栈内元素为12。

伪代码如下

stack<int> st;

for (遍历这个数组)
{
	if (栈空 || 栈顶元素大于等于当前比较元素)
	{
		入栈;
	}
	else
	{
		while (栈不为空 && 栈顶元素小于当前元素)
		{
			栈顶元素出栈;
			更新结果;
		}
		当前数据入栈;
	}
}

总结：上面整体的介绍可能有不清晰的地方，多多包涵。本题教我了不少东西，string.Contains(str,element)函数,字符串要改变某单个字符要怎么做，学习了贪心类问题新的解法，新的思路—单调栈。