Ac Wing 2021/5/28 每日一题 3583. 整数分组

原题:3583. 整数分组

3583. 整数分组

给定 n 个整数 a1,a2,…,an。

现在,请你从中挑选一些数,并将选出的数进行分组。

要求:

  1. 选出的数最多划分为 k 组(至少 1 组)。
  2. 同一组内,任意两数之差的绝对值不超过 5。
  3. 所选出的数尽可能多。

请问,最多可以选出多少个数进行分组?

输入格式

第一行包含两个整数 n 和 k。

第二行包含 nn 个整数 a1,a2,…,an。

输出格式

输出一个整数,表示可以选出的最大整数数量。

数据范围

1≤k≤n≤5000,
1≤ai≤10^9

输入样例1:

5 2
1 2 15 15 15

输出样例1:

5

输入样例2:

6 1
36 4 1 25 9 16

输出样例2:

2

输入样例3:

4 4
1 10 100 1000

输出样例3:

4

思路:首先想到的是贪心,后面列举了反例,比如k=1的时候很容易证明错误。之后想到了dp,首先定义dp[i][j]代表前i+1个数分j组最多能选取的数量。则出现两种情况就是若第i个数不选则dp[i][j]=dp[i-1][j];若选择第i个数,则查询它所能包括的区间,若该区间没有和其他区间重叠则dp[i][j]=dp[m][j-1]+i-m;若和其他区间重叠则将重叠部分分给后区间也是dp[i][j]=dp[m][j-1]+i-m;

综上所述,dp[i][j]=dp[i-1][j]//不选 =dp[m][j-1]+i-m;注意:第0个数有一个以上的区间则能选它,即为1。

代码:

向前版本:

#include <bits/stdc++.h>

using namespace std;

const int N = 5010;
int nums[N];
int dp[N][N];

int main()
{
    int n, k;
    cin >> n >> k;
    for (int i = 0; i < n; i++)
    {
        cin >> nums[i];
    }

    sort(nums, nums + n);

    for (int j = 1; j <= k; j++)
    {
        dp[0][j] = 1;
    }

    for (int i = 1; i < n; i++)
    {
        for (int j = 1; j <= k; j++)
        {
            dp[i][j] = max(dp[i][j], dp[i - 1][j]); //不选
            int m = i - 1;
            while (m >= 0 && (nums[i] - nums[m]) <= 5)m--;
            dp[i][j] = max(dp[i][j], ((m<0)?0:dp[m][j - 1]) + i - m); //分区
        }
    }
    cout << dp[n - 1][k] << endl;

    return 0;
}

向后版本:

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 5010;

int n, m;
int w[N];
int f[N][N];

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    sort(w + 1, w + n + 1);

    for (int i = 1, k = 1; i <= n; i ++ )
    {
        while (w[i] - w[k] > 5) k ++ ;
        for (int j = 1; j <= m; j ++ )
            f[i][j] = max(f[i - 1][j], f[k - 1][j - 1] + (i - k + 1));
    }

    printf("%d\n", f[n][m]);
    return 0;
}

 

由于没有Ac - Wing 4872题“最短路之和”的具体题目描述,下面提供通用的解决最短路问题的思路及示例代码,通常这类问题可以使用Dijkstra算法、Floyd算法等。 ### Dijkstra算法思路 Dijkstra算法用于求解单源最短路径问题,即从一个固定的起点到图中其他所有顶点的最短路径。其基本思想是维护一个距离数组`dist`,记录从起点到各个顶点的最短距离,初始时除起点外其他顶点的距离设为无穷大。每次从`dist`数组中选择距离最小且未被确定最短路径的顶点,然后以该顶点为中间点,更新其邻接顶点的距离。 ### Dijkstra算法Python代码示例 ```python import heapq from collections import defaultdict def dijkstra(graph, start): dist = {node: float(&#39;inf&#39;) for node in graph} dist[start] = 0 pq = [(0, start)] while pq: current_dist, current_node = heapq.heappop(pq) if current_dist > dist[current_node]: continue for neighbor, weight in graph[current_node].items(): distance = current_dist + weight if distance < dist[neighbor]: dist[neighbor] = distance heapq.heappush(pq, (distance, neighbor)) return dist # 示例图 graph = { &#39;A&#39;: {&#39;B&#39;: 1, &#39;C&#39;: 4}, &#39;B&#39;: {&#39;A&#39;: 1, &#39;C&#39;: 2, &#39;D&#39;: 5}, &#39;C&#39;: {&#39;A&#39;: 4, &#39;B&#39;: 2, &#39;D&#39;: 1}, &#39;D&#39;: {&#39;B&#39;: 5, &#39;C&#39;: 1} } start_node = &#39;A&#39; shortest_distances = dijkstra(graph, start_node) print(shortest_distances) ``` ### Floyd算法思路 Floyd算法用于求解图中任意两点之间的最短路径。其基本思想是通过动态规划的方法,逐步更新任意两点之间的最短距离。对于每一个中间点`k`,检查是否可以通过该中间点缩短任意两点`i`和`j`之间的距离。 ### Floyd算法Python代码示例 ```python INF = float(&#39;inf&#39;) def floyd(graph): n = len(graph) dist = [[graph[i][j] if graph[i][j] != 0 else INF for j in range(n)] for i in range(n)] for k in range(n): for i in range(n): for j in range(n): if dist[i][k] != INF and dist[k][j] != INF and dist[i][j] > dist[i][k] + dist[k][j]: dist[i][j] = dist[i][k] + dist[k][j] return dist # 示例图的邻接矩阵 graph = [ [0, 1, 4, INF], [1, 0, 2, 5], [4, 2, 0, 1], [INF, 5, 1, 0] ] shortest_distances = floyd(graph) for row in shortest_distances: print(row) ``` 如果要计算最短路之和,在得到所有最短路径后,将需要的最短路径距离相加即可。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值