LeetCode 1585 Check If String Is Transformable With Substring Sort Operations

题目

题意：一个只有0-9组成的字符串，每次选择任意一个子串，按照数字从小到大排序。问从源字符串能否经过若干次操作转换成目标字符串。

题解：首先题目只问了是否，而没有问多少次，所以可以判断出，我们不关心过程是怎么样的，只关心结果能否到达。所以不太可能是动态规划，搜索什么的。
既然是看结果，那估计是个找规律的题目。首先看目标字符串的第一个字符x，如果它是由源字符串的某个字符x经过排序之后，安排到了第一个位置，那么它一定满足，在源字符串中从起始位置到x的位置的子串中，x一定是最小的那个。否则x就无法移动到第一个位置。
一次内推，第二个字符x2, 由于第一个字符x已经确定了我们把x变成最大值，那么x2应该满足从源字符串起始位置到x2的位置的子串中，x2是最小的那个。

所以这道题目就变成了单点更新，求区间最值。
使用简单优雅的数据结构，树状数组，即可解决问题。
树状数组的区间最值，要比区间和复杂一点，且更新的时间效率是Log(n)*Log(n)
跟线段树比差一点。

class Solution {
public:
    int c[100005];
    int a[100005];
    vector<int> pos[10];
    int n;
    bool isTransformable(string s, string t) {
        
        for(int i = s.length()-1;i>=0;i--)
        {
            int num = s[i]-'0';
            pos[num].push_back(i+1);
        }
        
        n = s.length();
        for(int i=0;i<=n;i++)
        {
            c[i] = INT_MAX;
        }
        
        for(int i=0;i<s.length();i++)
        {
            add(i+1,s[i]-'0');
            a[i+1]=s[i]-'0';
        }
        
        for(int i=0;i<t.length();i++)
        {
            if(pos[t[i]-'0'].size()==0)
                return false;
            int p = pos[t[i]-'0'].back();
            pos[t[i]-'0'].pop_back();
            int m = get(1,p);
            if(m!=t[i]-'0')
                return false;
            
            add(p,INT_MAX);
        }
        
        return true;
        
    }
    
    int lowbit(int x)
    {
        return x&(-x);
    }
    
    void add(int index,int num)
    {
        a[index] = num;
        while(index<=n)
        {
            int l = index-lowbit(index)+1;
            int m = get(l, index-1);
            if(l==index)
            {
                c[index]=a[index];
            }
            else if(min(m, a[index])!=c[index])
            {
                c[index]=min(m, a[index]);
            }
            else
            {
                break;
            } 
            index+=lowbit(index);
        }
    }
    
    int get(int l, int r)
    {
        if(l>r)
            return INT_MAX;
        int ans = INT_MAX;
        while(r>=l)
        {
            if(r-lowbit(r) < l-1)
            {
                ans = min(ans, a[r]);
                r--;
            }
            else
            {
                ans = min(ans, c[r]);
                r-=lowbit(r);
            }
        }
        return ans;
    }
};