# 484. Find Permutation

**<font color=red>难度: Medium</font>**

## 刷题内容

> 原题连接

* https://leetcode.com/problems/find-permutation/

> 内容描述

```
By now, you are given a secret signature consisting of character 'D' and 'I'. 'D' represents a decreasing relationship between two numbers, 'I' represents an increasing relationship between two numbers. And our secret signature was constructed by a special integer array, which contains uniquely all the different number from 1 to n (n is the length of the secret signature plus 1). For example, the secret signature "DI" can be constructed by array [2,1,3] or [3,1,2], but won't be constructed by array [3,2,4] or [2,1,3,4], which are both illegal constructing special string that can't represent the "DI" secret signature.

On the other hand, now your job is to find the lexicographically smallest permutation of [1, 2, ... n] could refer to the given secret signature in the input.

Example 1:
Input: "I"
Output: [1,2]
Explanation: [1,2] is the only legal initial spectial string can construct secret signature "I", where the number 1 and 2 construct an increasing relationship.
Example 2:
Input: "DI"
Output: [2,1,3]
Explanation: Both [2,1,3] and [3,1,2] can construct the secret signature "DI", 
but since we want to find the one with the smallest lexicographical permutation, you need to output [2,1,3]
Note:

The input string will only contain the character 'D' and 'I'.
The length of input string is a positive integer and will not exceed 10,000
```

## 解题方案

> 思路 1
******- 时间复杂度: O(N)******- 空间复杂度: O(N)******


自己找到了一个规律，首先lexicographically smallest permutation肯定是[1,2,3...,n]，但是我们还需要满足题目要求

于是发现只要是出现了D的地方，就直接给res对应区间反转一下就可以


比如input为"DDIIID"，初始res = [1,2,3,4,5,6,7]

前两个D，我们就将前三个数字反转，res = [3,2,1,4,5,6,7]

继续进行下去，最后一个是D，所以最后两个数字反转，res = [3,2,1,4,5,7,6]

其实就是碰到连续的n个D就将res中对应长度n+1的区间反转即可

我们可以用一个栈辅助一下，这样比较简单

beats 68.09%

```python
class Solution:
    def findPermutation(self, s):
        """
        :type s: str
        :rtype: List[int]
        """
        res = []
        stack = []
        for i in range(1, len(s)+1):
            if s[i-1] == 'I':
                stack.append(i)
                while stack:
                    res.append(stack.pop())
            else:
                stack.append(i)
        stack.append(len(s)+1)
        while stack:
            res.append(stack.pop())
        return res
```



> 思路 2
******- 时间复杂度: O(N)******- 空间复杂度: O(1)******


我们也可以不用栈，直接从头到尾遍历即可


为了处理方便，我们可以将s最后加上一个'I'，这样不影响结果并且容易处理

beats 89.36%

```python
class Solution:
    def findPermutation(self, s):
        """
        :type s: str
        :rtype: List[int]
        """
        if not s or len(s) == 0:
            return []
        s += 'I'
        res = [i for i in range(1, len(s)+1)]
        i = 0
        while i < len(s) - 1:
            if s[i] == 'I':
                i += 1
            else:
                start = i
                while i < len(s) - 1 and s[i] == 'D':
                    i += 1
                res[start:i+1] = res[start:i+1][::-1]
        return res
```
































