[洛谷P1902]刺杀大使

本文介绍了洛谷P1902题目的解题思路,作者分享了尝试使用SPFA算法但未能通过的情况,最终采用二分搜索配合验证的方法解决问题。

题目←

总觉得spfa一脸可做的样子然而过不了
于是乖乖打了二分+验证

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 1000 + 50;
int mr[] = {0,1,-1,0},
    mu[] = {1,0,0,-1};
bool used[MAXN][MAXN];
int n,m;
bool in(int x,int y){
    if(x < 1 || y < 1)return false;
    if(x > n || y > m)return false;
    return true;
}
int lim;
int map[MAXN][MAXN];
struct zt{
    int x,y;
};
queue <zt> q;
bool C(){
    memset(used,0,sizeof(used));
    while(!q.empty())q.pop();
    for(int i = 1;i <= m;i ++){
        q.push((zt){1,i});
        used[1][i] = true;
    }
    while(!q.empty()){
        zt u = q.front();
        q.pop();
        for(int i = 0;i <= 3;i ++){
            int x = u.x + mu[i];
            int y = u.y + mr[i]; 
            if(x < 1 || y < 1 || x > n || y > m || used[x][y] || map[x][y] > lim)continue;
            q.push((zt){x,y});
            used[x][y] = true;
            if(x == n){
                return true;
            }
        }
    }
    return false;
}
int lin[MAXN*MAXN],tot,maxx,L,R;
int main(){
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= n;i ++){
        for(int j = 1;j <= m;j ++){
            scanf("%d",&map[i][j]);
            lin[++ tot] = map[i][j];
        }
    }
    sort(lin + 1,lin + tot + 1);
    tot = unique(lin + 1,lin + tot + 1) - lin - 1;
    L = -1;R = tot + 1;
    while(R - L > 1){
        int mid = R + L >> 1;
        lim = lin[mid];
        if(C())R = mid;
        else L = mid;
    }
    printf("%d",lin[R]);
}
### P1902 刺杀大使 的 Java 实现分析 #### 问题背景 P1902 刺杀大使 是一个经典的算法竞赛题目,通常涉及路径规划、动态规划或者贪心策略等问题。该问题的核心在于如何通过最优的方式完成一系列目标节点的访问并返回起点。 以下是基于此问题的一个可能的解决方案及其核心逻辑: --- #### 动态规划解法概述 对于此类问题,可以采用 **状态压缩动态规划** 来解决。其基本思路是利用二进制位来表示当前已经访问过的节点集合,并记录到达某个特定节点时所需的最小代价[^1]。 具体来说,设 `dp[mask][i]` 表示已访问节点集合为 `mask` 并且最后停留在第 `i` 个节点时的最小总成本,则转移方程如下: \[ dp[mask | (1 << j)][j] = \min(dp[mask | (1 << j)][j], dp[mask][i] + cost[i][j]) \] 其中: - \( mask \) 是一个整数,用于存储当前已访问节点的状态。 - \( i, j \) 分别代表两个不同的节点编号。 - \( cost[i][j] \) 表示从节点 \( i \) 移动到节点 \( j \) 所需的成本。 最终答案可以通过枚举所有可能的结束节点得到。 --- #### Java 实现代码 下面是一个完整的 Java 实现代码片段,适用于上述描述的问题场景: ```java import java.util.*; import java.io.*; public class Main { static final int INF = Integer.MAX_VALUE; public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String[] input = br.readLine().split(" "); int n = Integer.parseInt(input[0]); // 节点数量 int m = Integer.parseInt(input[1]); // 边的数量 // 初始化邻接矩阵 int[][] graph = new int[n][n]; for(int i=0; i<n; ++i){ Arrays.fill(graph[i], INF); graph[i][i] = 0; } // 输入边的信息 for(int i=0;i<m;++i){ input = br.readLine().split(" "); int u = Integer.parseInt(input[0])-1; int v = Integer.parseInt(input[1])-1; int w = Integer.parseInt(input[2]); graph[u][v] = Math.min(graph[u][v],w); // 可能存在重边 } // Floyd-Warshall预处理最短路 floydWarshall(graph,n); // DP部分 int totalMask = 1<<n; int startNode = 0; // 假定起始节点为0号节点 long[][] dp = new long[totalMask][n]; // 初始化DP数组 for(int mask=0; mask<totalMask; ++mask){ Arrays.fill(dp[mask],INF); } dp[1<<startNode][startNode] = 0; // 状态转移 for(int mask=0; mask<(1<<n); ++mask){ for(int lastVisited=0; lastVisited<n; ++lastVisited){ if( (mask & (1<<lastVisited)) != 0 ){ for(int nextVisit=0; nextVisit<n; ++nextVisit){ if( (mask & (1<<nextVisit))==0 && graph[lastVisited][nextVisit]!=INF ){ int newMask = mask | (1<<nextVisit); dp[newMask][nextVisit] = Math.min( dp[newMask][nextVisit], dp[mask][lastVisited]+graph[lastVisited][nextVisit] ); } } } } } // 计算最终结果 long result = INF; int fullMask = (1<<n)-1; for(int end=0;end<n;end++){ if(graph[end][startNode]==INF || dp[fullMask][end]==INF) continue; result = Math.min(result, dp[fullMask][end] + graph[end][startNode]); } System.out.println((result==INF ? -1 : result)); // 如果无法完成则输出-1 } private static void floydWarshall(int[][] dist,int N){ for(int k=0;k<N;k++)for(int i=0;i<N;i++)if(dist[i][k]<INF)for(int j=0;j<N;j++)dist[i][j]=Math.min(dist[i][j],dist[i][k]+dist[k][j]); } } ``` --- #### 关键点解析 1. 预处理阶段采用了弗洛伊德(Floyd-Warshall)算法计算任意两点间的最短距离[^2]。 2. 使用了二维数组 `dp[mask][i]` 存储子问题的结果,从而避免重复计算。 3. 时间复杂度主要由两部分构成:Floyd-Warshall 的时间复杂度为 \(O(N^3)\),而状态转移的时间复杂度为 \(O(2^N * N^2)\)[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值