SPFA算法解决无限不可表示数问题-优快云博客

本文探讨了使用SPFA算法解决一组数字在正整数范围内无法表示的数的数量问题，通过对比BFS算法，详细展示了SPFA算法的具体实现过程及优势。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意是：给出一组数字，然后让你判断在正整数中不能由这些数字表示的数的个数，感觉就是一个BFS,可是怎么gao都不行就是wa，后来在大神提示下，明白了SPFA可破，哎，我那可怜的BFS怎么就是过不了，望路过的大神不吝赐教。

//用最短路模拟求解不同余数的最小数，队列中存的是小于data[0]的不同余数，每次将不同的余数加入队列
#include <iostream>
#include <queue>
#include <set>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <algorithm>

#define LL long long
#define min(a,b) a>b?b:a

using namespace std;
const LL inf=1ll<<55;
const int maxn=100010;
LL dist[maxn];
int hash[maxn];
int data[40];
int node;

void init()
{

	int i;
	for(i=0;i<maxn;i++)
	{
		dist[i]=inf;
		hash[i]=0;
	}


}

LL SPFA()
{
	LL ans=0,now;
	queue<int> que;
	que.push(0);
	hash[0]=1;
	dist[0]=0;
	while(!que.empty())
	{
		now=que.front();
		que.pop();
		hash[now]=0;
		for(int i=0;i<node;i++)
		{
			int v=(dist[now]+data[i])%data[0];
			if(dist[v]>dist[now]+data[i])
			{
				dist[v]=dist[now]+data[i];
				if(hash[v]==0)
				{
					que.push(v);
					hash[v]=1;
				}


			}


		}
	}

	for(int i=1;i<data[0];i++)
	{
		if(dist[i]>=inf)
			return -1;
		else
		{
			ans+=dist[i]/data[0];
		}

	}
	return ans;
}

int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&node);
		for(int i=0;i<node;i++)
			scanf("%d",&data[i]);
		sort(data,data+node);
		init();
		LL result=SPFA();
		if(result==-1)
			printf("Infinite\n");
		else
			printf("%lld\n",result);

	}

}

java写BFS就是一直wa到底是哪的错？，大神指点呀

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;
public class spoj8281 {
	static int maxn=100010;
	static long inf=1<<60;
	static long data[]=new long[maxn];
	static long initdata[]=new long[maxn];
	static int number;
	
	public static void main(String[] args) {
		
		Scanner in=new Scanner(System.in);
		int casenum=in.nextInt();;
		while(casenum--!=0)
		{
			long ans=0;
			PriorityQueue<Long> lis =new PriorityQueue<Long>(100010,new Comparator<Long>(){
				public int compare(Long a,Long b)
				{
					if(a<b)
						return -1;
					else
						return 1;
				}
			});
			number=in.nextInt();
			for(int i=0;i<number;i++)
			{
				initdata[i]=in.nextInt();
			}
			Arrays.sort(initdata,0,number);
			Arrays.fill(data, inf);
			long len=initdata[0];
			int index=0;
			for(int i=0;i<number;i++)
			{
			int flag=(int) (initdata[i]%initdata[0]);
			if(data[flag]>=inf)
			{
				lis.add(initdata[i]);
				data[flag]=initdata[i];
				ans+=data[flag]/initdata[0];
				index++;
			}
			}
			boolean f=true;
			if(index<len)
			{
				f=false;
			while(!lis.isEmpty())
			{
				long te1=lis.poll();
				for(int i=0;i<number;i++)
				{
					long te2=te1+initdata[i];
					int te3=(int) (te2%initdata[0]);
					if(data[te3]==inf)
					{
						data[te3]=te2;
						ans+=data[te3]/initdata[0];
						index++;
						if(index==len)
						{
							f=true;
							break;
						}
						lis.add(te2);
					}
				}
				if(index==len)
					break;
			}
			}
			if(f)
				System.out.println(ans-1);
			else
				System.out.println("Infinite");
			
		}
	}
}