力扣每日一题 0304-0306

994 烂橘子

在给定的网格中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。

返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。

 

示例 1：

输入：[[2,1,1],[1,1,0],[0,1,1]]
输出：4
示例 2：

输入：[[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。
示例 3：

输入：[[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rotting-oranges
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

写一个迭代形式的BFS就搞定了 需要一个queue和记录queue size的int值来记录每一步需要对多少元素进行操作

保存元素tag=行号*行元素数+列号来保存

class Solution {
public:
    int orangesRotting(vector>& grid) {
         if(grid.size()==0){
             return 0;
         }
         if(grid[0].size()==0){
             return 0;
         }
         queue rotting;
         int fresh=0;
         int x=grid.size();
         int y=grid[0].size();
         for(int i{0};i0){
                cur=rotting.front();
                rotting.pop();
                if(cur/y>0&&grid[cur/y-1][cur%y]==1){
                    grid[cur/y-1][cur%y]=2;
                    rotting.push(cur-y);
                    fresh--;
                }
                if(cur%y>0&&grid[cur/y][cur%y-1]==1){
                    grid[cur/y][cur%y-1]=2;
                    rotting.push(cur-1);
                    fresh--;
                }
                if(cur%y

 

1103 分糖果

我们买了一些糖果 candies，打算把它们分给排好队的 n = num_people 个小朋友。

给第一个小朋友 1 颗糖果，第二个小朋友 2 颗，依此类推，直到给最后一个小朋友 n 颗糖果。

然后，我们再回到队伍的起点，给第一个小朋友 n + 1 颗糖果，第二个小朋友 n + 2 颗，依此类推，直到给最后一个小朋友 2 * n 颗糖果。

重复上述过程（每次都比上一次多给出一颗糖果，当到达队伍终点后再次从队伍起点开始），直到我们分完所有的糖果。注意，就算我们手中的剩下糖果数不够（不比前一次发出的糖果多），这些糖果也会全部发给当前的小朋友。

返回一个长度为 num_people、元素之和为 candies 的数组，以表示糖果的最终分发情况（即 ans[i] 表示第 i 个小朋友分到的糖果数）。

 

示例 1：

输入：candies = 7, num_people = 4
输出：[1,2,3,1]
解释：
第一次，ans[0] += 1，数组变为 [1,0,0,0]。
第二次，ans[1] += 2，数组变为 [1,2,0,0]。
第三次，ans[2] += 3，数组变为 [1,2,3,0]。
第四次，ans[3] += 1（因为此时只剩下 1 颗糖果），最终数组变为 [1,2,3,1]。
示例 2：

输入：candies = 10, num_people = 3
输出：[5,2,3]
解释：
第一次，ans[0] += 1，数组变为 [1,0,0]。
第二次，ans[1] += 2，数组变为 [1,2,0]。
第三次，ans[2] += 3，数组变为 [1,2,3]。
第四次，ans[0] += 4，最终数组变为 [5,2,3]。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/distribute-candies-to-people
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

每一次发都比上次+1 构成一个等差数列

即求发了完整的多少次 然后取余一一分配就行了 剩下的给下一个小朋友

class Solution {
public:
    vector distributeCandies(int candies, int num_people) {
        vector ans(num_people,0);
        //sqrt(2*c+0.25)-1.5<=p

 

面试题57 - II. 和为s的连续正数序列

输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

 

示例 1：

输入：target = 9
输出：[[2,3,4],[4,5]]
示例 2：

输入：target = 15
输出：[[1,2,3,4,5],[4,5,6],[7,8]]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/he-wei-sde-lian-xu-zheng-shu-xu-lie-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

两种解法：双指针滑动窗口 要滑到n/2 复杂度O(n)

数学方法：

与分糖果类似 可能的最长数组就是1+……+p 余下值remain

然后i从0-(p-2)扫描 将前面数加到remain中 若remain%(p-i)=0 说明子数组(i+1)-p可以满足要求 

复杂度O(n^(1/2))

 

class Solution {
public:
    vector> findContinuousSequence(int target) {
    	vector> answer;
        int p = sqrt(2.0*target + 0.25) - 0.5;
        int remain = target - p*(p + 1) / 2;
        vector cur;
        for (int i{ 0 }; i <= p;i++)
        {
            cur.push_back(i);
        }
        for (int j{ 0 }; j < p - 1; j++)
        {
            remain += cur[j];
            if (remain % (p - j)==0){
                for (int i{ j + 1 }; i <= p; i++)
                {
                    cur[i] += remain / (p - j);
                }
                remain = 0;
            }
            if (remain == 0){
                vector ans(cur.begin() + j + 1, cur.end());
                answer.push_back(ans);
            }
            
        }
        return answer;
    }
};

归根结底还是考数学啊