推倒多米诺骨牌

class Solution:
    def fill(self, arr, x, y, mode='RL'):
        if x<y:
            if mode=='RL':
                mid=(x+y)//2
                if (y-x)%2==0:
                    arr[x:mid]=['R']*(mid-x)
                    arr[mid+1:y+1]=['L']*(mid-x)
                else:
                    arr[x:mid+1]=['R']*(mid-x+1)
                    arr[mid+1:y+1]=['L']*(mid-x+1)
            elif mode=='LL':
                arr[x:y]=['L']*(y-x)
            elif mode=='RR':
                arr[x:y]=['R']*(y-x)
        return arr
    def solve(self, s ):
        # write code here
        arr=list(s)
        count=0
        last_c=''
        last_i=0
        for i, c in enumerate(arr):
            if c!='.':
                if count==0:
                    count+=1
                    if c=='L':
                        arr=self.fill(arr, 0, i, 'LL')
                else:
                    arr=self.fill(arr, last_i, i, last_c+c)
                last_i, last_c=i, c
        if last_c=='R':
            arr=self.fill(arr, last_i, len(s), 'RR')
        return ''.join(arr) 

我的思路是这样的：

1. 将字符串拆分成字符数组
2. 查找里面 L 和 R 的位置
3. 如果：L 在 R 的右侧，则执行
   3.1 查找 L 和 R 的中间位置 center
   3.2 将 center 往右、L 往左的元素设置为 L
   3.3 将 center 往左、R 往右的元素设置为 R
4. L 在 R 的左侧，执行：
   4.1 将 0 往右、L 往左的元素设置为 L
   4.2 将 R 往右、最后一个元素及其往前的元素设置为 R

这样的思路能满足题目示例的用例，但最后一个测试用例都没有过得了，求大佬指点 /bq/bq

function solve( s ) {
  const arr = s.split("");
  const LIndex = arr.findIndex(item => item === "L");
  const RIndex = arr.findIndex(item => item === "R");

  if (LIndex > RIndex) {
    const center = (LIndex - RIndex) / 2 + RIndex;
    for(let i = RIndex + 1; i < center; i++) {
      arr[i] = "R";
    }
    for(let i = LIndex - 1; i > center; i--) {
      arr[i] = "L";
    }
  } else {
    for(let i = 0; i < LIndex; i++) {
      arr[i] = "L";
    }
    for(let i = RIndex; i < arr.length; i++) {
      arr[i] = "R";
    }
  }
  return arr.join("");
}
module.exports = {
    solve : solve
};

//暴力解法
function solve( s ) {
    // write code here
    var arr = s.split("")
    var flag_l = -1;
    var flag_r = -1;
    for(let i = 0; i < arr.length; i ++) {
        if(arr[i]==='R'&&flag_r===-1) flag_r = i;
        else if(arr[i]==='L'&&flag_l===-1) flag_l = i;
        //遇到L之前都没有遇到R
        if(flag_l!==-1&&flag_r===-1) {
            while(flag_l>=0&&arr[--flag_l]==='.') {
                arr[flag_l] = 'L'
            }
            flag_l = -1;
        }
        //遇到R直到结束都没有再次遇到L
        else if(flag_r!==-1&&flag_l===-1&&i===arr.length-1) {
            while(flag_r<arr.length) {
                arr[flag_r++] = 'R'
            }
        }
        //先遇到R在遇到L
        else if(flag_l!==-1&&flag_r!==-1) {
            
            while(flag_r < flag_l) {
                arr[flag_r++] = 'R'
                arr[flag_l--] = 'L'
            }
            flag_l = -1;
            flag_r = -1;
        }
        //先遇到R遭遇到R
        else if(arr[i]==='R'&&flag_r!==-1&&flag_l===-1) {
            while(flag_r < i) {
                arr[flag_r++] = 'R'
            }
            flag_r = i;
        }
    }
    let result = ''
    arr.forEach(value => {
        result+=value
    });
    return result
}

#include <vector>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param s string字符串 
     * @return string字符串
     */
    string solve(string s) {
        // write code here
        vector<vector<int> > typeVec;
        int l=-1,r=-1;

        for (int i=0;i<s.size();i++){
            if (s[i]=='L'){
                if (r>=0){
                    l=i;
                    vector<int> vec = {0,r,l};
                    typeVec.push_back(vec);
                    r=-1;
                    l=-1;
                }
                else{
                    l = i;
                    vector<int> vec = {1, l};
                    typeVec.push_back(vec);
                    l = -1;
                }
            }
            else if (s[i]=='R'){
                if (r<0) r = i;
                else{
                    vector<int> vec = {2, r};
                    typeVec.push_back(vec);
                    r = i;
                }
            }
            else if (i==s.size()-1 && r>0){
                vector<int> vec = {2, r};
                typeVec.push_back(vec);
            }
        }

        for (int i=0; i<typeVec.size(); i++){
            if (typeVec[i][0]==0){ // RL
                int r=typeVec[i][1], l=typeVec[i][2];
                while (l>r && r!=s.size()){
                    s[r++] = 'R';
                    if (l>0){
                        s[l--]='L';
                    }
                }
            }
            else if (typeVec[i][0]==1){ // L
                int idx = typeVec[i][1] - 1;
                while (idx>=0 && s[idx]=='.') s[idx--] = 'L';
            }
            else if (typeVec[i][0]==2){ // R
                int idx = typeVec[i][1] + 1;
                while (idx<s.size() && s[idx]=='.') s[idx++] = 'R';
            }
        }
        return s;
    }
};