第123场周赛

1,989.数组形式的整数加法

---

 

方法一：逐位相加

思路

让我们逐位将数字加在一起。举一个例子，如果要计算 123 与 912 的和。我们顺次计算 3+2、2+1、1+9。任何时候，当加法的结果大于等于 10 ，我们要将进位的 1 加入下一位的计算中去，所以最终结果等于 1035。

算法

我们可以对以上的想法做一个小变化，让它实现起来更容易 —— 我们将整个加数加入数组表示的数的最低位。

继续之前的例子 123+912，我们把它表示成 [1, 2, 3+912]。然后，我们计算 3+912 = 915。5 留在当前这一位，将 910/10=91 以进位的形式加入下一位。

然后，我们再重复这个过程，计算 [1, 2+91, 5]。我们得到 93，3 留在当前位，将 90/10=9 以进位的形式加入下一位。继而又得到 [1+9, 3, 5]，重复这个过程之后，最终得到结果 [1, 0, 3, 5]。

---

class Solution {
public:
    vector<int> addToArrayForm(vector<int>& A, int K) {
        int N=A.size();
        int cur=K;
        vector<int> ans;
        for(int i=N-1;i>=0;i++){
            if(i>=0)    
                cur+=A[i];
            ans.push_back(cur%10);
            cur/=10;
        }
        reverse(ans.begin(),ans.end());
        return ans;
    }
};

2,990.等式方程的可满足性(深度优先遍历)

---

方法一：联通分量

思路

所有相互等于的变量能组成一个联通分量。举一个例子，如果 a=b, b=c, c=d，那么 a, b, c, d 就在同一个联通分量中，因为它们必须相等。

算法

第一步，我们基于给定的等式，用深度优先遍历将每一个变量按照联通分量染色。

将联通分量染色之后，我们分析形如 a != b 的不等式。如果两个分量有相同的颜色，那么它们一定相等，因此如果说它们不相等的话，就一定无法满足给定的方程组。

否则，我们的染色就可以看作是一组能满足方程组约束的方案，所以结果是 true。

---

class Solution {
public:
    bool equationsPossible(vector<string>& equations) {
        vector<vector<int> > graph(26);
        for(auto eqn:equations){
            if(eqn[1]=='='){
                int x=eqn[0]-'a';
                int y=eqn[3]-'a';
                graph[x].push_back(y);
                graph[y].push_back(x);
            }
        }
        vector<int> color(26);
        int t=0;
        for(int start=0;start<26;start++){
            if(color[start]==0){
                t++;
                stack<int> stac;
                stac.push(start);
                while(!stac.empty()){
                    int node=stac.top();
                    stac.pop();
                    for(int nei:graph[node]){
                        if(color[nei]==0){
                            color[nei]=t;
                            stac.push(nei);
                        }
                    }
                }
            }
        }
        for(string eqn:equations){
            if(eqn[1]=='!'){
                int x=eqn[0]-'a';
                int y=eqn[3]-'a';
                if(x==y||color[x]!=0&&color[x]==color[y])
                    return false;
            }
        }
        return true;
    }
};

3,991.坏了的计算器（贪心）

---

方法一：逆向操作

思路

除了对 X 执行乘 2 或 减 1 操作之外，我们也可以对 Y 执行除 2（当 Y 是偶数时）或者 加 1 操作。

这样做的动机是我们可以总是贪心地执行除 2 操作：

• 当 Y 是偶数，如果先执行 2 次加法操作，再执行 1 次除法操作，我们可以通过先执行 1 次除法操作，再执行 1 次加法操作以使用更少的操作次数得到相同的结果 [(Y+2) / 2 vs Y/2 + 1]。

• 当 Y 是奇数，如果先执行 3 次加法操作，再执行 1 次除法操作，我们可以将其替代为顺次执行加法、除法、加法操作以使用更少的操作次数得到相同的结果 [(Y+3) / 2 vs (Y+1) / 2 + 1]。

算法

当 Y 大于 X 时，如果它是奇数，我们执行加法操作，否则执行除法操作。之后，我们需要执行 X - Y 次加法操作以得到 X。

---

class Solution {
public:
    int brokenCalc(int X, int Y) {
        int ans=0;
        while(Y>X){
            ans++;
            if(Y%2==1)
                Y++;
            else
                Y/=2;
        }
        return ans+X-Y;
    }
};