力扣第 283 场周赛

题目链接

6016. Excel 表中某个范围内的单元格

类似于二维数组遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
public:
    vector<string> cellsInRange(string s) {
        vector<string> ans;
        for(char c=s[0];c<=s[3];c++)
        {
            for(char i=s[1];i<=s[4];i++)
            {
                string a;
                a.resize(2);
                a[0]=c;
                a[1]=i;
                ans.push_back(a);
            }
        }
        return ans;
    }
    
};

6017. 向数组中追加 K 个整数

手菜当时快把我调自闭了

面向数据编程wa了6发

嘤

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Solution {
public:
    long long minimalKSum(vector<int>& nums, int k) {
long long ans = 0;
    long long p = 1;
    int i = 0;
    sort(nums.begin(), nums.end());
    if(nums[0]!=1)
    {
        if(k<nums[0])
    {
        ans=(1LL+k)*k/2;
        k=0;
    }
    else
    {
        k-=nums[0]-1;
        p=nums[0];
        ans=(nums[0]-1LL)*nums[0]/2;
    }
    }
    while (k && i < nums.size())
    {
        while (i + 1 < nums.size() && nums[i] == nums[i + 1]) i++;
        if (p != nums[i])
        {
            while (p != nums[i])
            {
                ans += p;
                p++;
                k--;
                if (!k) break;
            }
        }
        i++; p++;
    }
    if(k)
    {
        ans+=(p+p+k-1LL)*k/2;
    }
        return ans;
    }
};

太丑了嫌弃自己

赛后看了hls的代码

排序后计算相邻两个nums的l r 取值

好有道理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Solution {
    long long ans=0;
    inline void so(long long l,long long r,int& k)
    {
        if(l > r) return;
        if(k<=r-l+1)
        r=l+k-1;
        ans+=(l+r)*(r-l+1)/2;
        k-=r-l+1;
        return;
    }
public:
    long long minimalKSum(vector<int>& nums, int k) {
        sort(nums.begin(),nums.end());

        so(1LL,nums[0]-1,k);
        for(int i=0;k&&i+1<nums.size();i++)
        so(nums[i]+1,nums[i+1]-1,k);

        if(k)
        ans+=(nums[nums.size()-1]*2LL+k+1)*k/2;

        return ans;
    }
};

2196. 根据描述创建二叉树

map + 模拟

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    map<int,TreeNode*> mp;
    bool vis[100005]={0};
public:
    TreeNode* createBinaryTree(vector<vector<int>>& descriptions) {
        int l=descriptions.size();
        
        for(int i=0;i<l;i++)
        {
            if(mp[descriptions[i][0]]&&mp[descriptions[i][1]]);
            else if(mp[descriptions[i][1]])
            {
                TreeNode* a=new(TreeNode);
                a->val=descriptions[i][0];
                mp[a->val]=a;
                
                
            }
            else if(mp[descriptions[i][0]])
            {
                TreeNode* a=new(TreeNode);
                a->val=descriptions[i][1];
                mp[a->val]=a;
            }
            else
            {
                TreeNode* a=new(TreeNode);
                a->val=descriptions[i][1];
                mp[a->val]=a;
                
                TreeNode* b=new(TreeNode);
                b->val=descriptions[i][0];
                mp[b->val]=b;
            }
            vis[descriptions[i][1]]=1;
            if(descriptions[i][2]) mp[descriptions[i][0]]->left=mp[descriptions[i][1]];
            else
                mp[descriptions[i][0]]->right=mp[descriptions[i][1]];
        }
        for(auto i: mp)
        if(!vis[i.first] ) return i.second;
        return NULL;
    }
};

2197. 替换数组中的非互质数

栈 + 模拟 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Solution {
public:
    vector<int> replaceNonCoprimes(vector<int>& nums) {
        vector <int>ans;
        int p=nums[0];
        for(int i=1;i<nums.size();i++)
        {
            int x=__gcd(nums[i],p);
            if(x!=1) 
            p=p/x*nums[i];
            else
            {
                while(ans.size())
                {
                    x=__gcd(ans[ans.size()-1],p);
                    if(x!=1)
                    {
                        p=p/x*ans[ans.size()-1];
                        ans.pop_back();
                    }
                    else
                    break;
                }
                ans.push_back(p);
                p=nums[i];
            }
        }
        while(ans.size())
                {
                    int x=__gcd(ans[ans.size()-1],p);
                    if(x!=1)
                    {
                        p=p/x*ans[ans.size()-1];
                        ans.pop_back();
                    }
                    else
                    break;
                }
                ans.push_back(p);
        return ans;
    }
};