leetcode 821. 字符的最短距离(Shortest Distance to a Character)

给定一个字符串 S 和一个字符 C。返回一个代表字符串 S 中每个字符到字符串 S 中的字符 C 的最短距离的数组。

示例 1:

输入: S = "loveleetcode", C = 'e'
输出: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0]

说明:

1. 字符串 S 的长度范围为 [1, 10000]。
2. C 是一个单字符，且保证是字符串 S 里的字符。
3. S 和 C 中的所有字母均为小写字母。

 

 

暴力解决 j，k 通过 j-- k++来查找最近的C

 

class Solution {
    public int[] shortestToChar(String S, char C) {
        int[] ans = new int[S.length()];
        for(int i=0;i<S.length();i++) {
        	int j=i,k=i;
        	boolean flag1= false,flag2 = false;
        	while(j>=0) {
        		if(S.charAt(j)==C) {
        			flag1=true;
        			break;
        		}
        		j--;
        	}
        	while(k<S.length()) {
        		if(S.charAt(k)==C) {
        			flag2=true;
        			break;
        		}
        		k++;
        	}
        	if(!flag1)
        		ans[i]=Math.abs(k-i);
        	else if(!flag2)
        		ans[i]=Math.abs(j-i);
        	else
        		ans[i]=Math.min(Math.abs(j-i),Math.abs(k-i));
        }
        
        return ans;    
    }
}

 

beat 100%

class Solution {
    public int[] shortestToChar(String S, char C) {
        int[] res = new int[S.length()];

        int last = Integer.MAX_VALUE;
        int next = S.indexOf(C);
        int current = 0;
        int diff;
        while (current < S.length())
        {
            diff = Math.min(Math.abs(current - last), Math.abs(next - current));
            res[current] = diff;
            if(current == next)
            {
                last = next;
                next = S.indexOf(C,current + 1);
                if(next == -1)
                {
                    next = Integer.MAX_VALUE;
                }
            }
            current++;

        }

        return res;
    }
}

 

 

 

leetcode外网的大佬总结

说明
初始结果数组。
在字符串上循环两次S。
第一个向前传球找到左边最短的角色。
第二次向后传球，找到右边最短的角色。

 

注意
在python解决方案中，我合并了这两个for语句。
我可以通过以下方式在C ++ / Java中执行相同的操作：

 

for (int i = 0; i >= 0; res[n-1] == n ? ++i : --i)

但它会变得不那么可读。

 

时间复杂度 O（N）

 

C ++

 

    vector<int> shortestToChar(string S, char C) {
        int n = S.size();
        vector<int> res(n, n);
        int pos = -n;
        for (int i = 0; i < n; ++i) {
            if (S[i] == C) pos = i;
            res[i] = min(res[i], abs(i - pos));
        }
        for (int i = n - 1; i >= 0; --i) {
            if (S[i] == C)  pos = i;
            res[i] = min(res[i], abs(i - pos));
        }
        return res;
    }

 

Java的

 

    public int[] shortestToChar(String S, char C) {
        int n = S.length();
        int[] res = new int[n];
        int pos = -n;
        for (int i = 0; i < n; ++i) {
            if (S.charAt(i) == C) pos = i;
            res[i] = i - pos;
        }
        for (int i = n - 1; i >= 0; --i) {
            if (S.charAt(i) == C)  pos = i;
            res[i] = Math.min(res[i], Math.abs(i - pos));
        }
        return res;
    }

 

蟒蛇

 

 def shortestToChar(self, S, C):
        n = len(S)
        res = [n] * n
        pos = -n
        for i in range(n) + range(n)[::-1]:
            if S[i] == C: pos = i
            res[i] = min(res[i], abs(i - pos))
        return res

 

另一个想法非常相似。
我们首先给它一个循环来找到所有字符C并将距离初始化为0. 
同样，我们可以将额外的传递合并到前传传递，例如：

 

for (int i = 0; i < n; ++i) if (S[i] == C) res[i] = 0; else if (i > 0) res[i] = res[i - 1] + 1;

 

但它会变得不那么可读。

 

C ++：

 

    vector<int> shortestToChar(string S, char C) {
        int n = S.size();
        vector<int> res(n, n);
        for (int i = 0; i < n; ++i) if (S[i] == C) res[i] = 0;
        for (int i = 1; i < n; ++i) res[i] = min(res[i], res[i - 1] + 1);
        for (int i = n - 2; i >= 0; --i) res[i] = min(res[i], res[i + 1] + 1);
        return res;
    }

 

Java的：

 

    public int[] shortestToChar(String S, char C) {
        int n = S.length();
        int[] res = new int[n];
        for (int i = 0; i < n; ++i) res[i] = S.charAt(i) == C ? 0 : n;
        for (int i = 1; i < n; ++i) res[i] = Math.min(res[i], res[i - 1] + 1);
        for (int i = n - 2; i >= 0; --i) res[i] = Math.min(res[i], res[i + 1] + 1);
        return res;
    }

 

蟒蛇：

 

    def shortestToChar(self, S, C):
        n = len(S)
        res = [0 if c == C else n for c in S]
        for i in range(n - 1): res[i + 1] = min(res[i + 1], res[i] + 1)
        for i in range(n - 1)[::-1]: res[i] = min(res[i], res[i + 1] + 1)
        return res