「java实现dfs」Java实现接口
今天给各位分享java实现dfs的知识，其中也会对Java实现接口进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、JAVA中如何查找字符串
- 2、fastdfs java 怎么使用
- 3、一个N位的十进制正整数，如果它的每个位上的数字的N次方的和等于这个数本身，则称其为花朵数。 例如： 当N
- 4、java实现二进制穷举
- 5、分别用DFS和BFS算法给电脑设置AI(JAVA)
- 6、JAVA求10个景点间各个景点的最短路径 图随便话 距离随便 求代码
JAVA中如何查找字符串
问题很简单：
1.首先，你的数据源是数组，那么要想对每一个值作操作，必须遍历，所以就有如下代码：
for(int i=0;iA.length;i++){
...
}
2.在循环当中，数组中的每一个正在遍历的元素，就是：A[i];
3.String是java的一个字符串处理类，他有一个非常好用的方法就是，
public boolean startsWith(String prefix)，测试此字符串是否以指定的前缀开始。 所以：A[i].startsWith("C")如果返回true，那么他就是以C开头的。
4.综上所述，实现很简单，完成代码如下：
public class Test{
public static void main(String[] args){
String[] A ={"CSDF","FDS","CFDSA","DFS","FET"};
for(int i=0;iA.length;i++){
if(A[i].startsWith("C")){
System.out.println(A[i]);
}
}
}
}
总结：
临时写的，代码没有经过测试，但敢保证其正确性的几率很大，祝你成功。
fastdfs java 怎么使用
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.io.FilenameUtils;
import org.apache.log4j.Logger;
import org.csource.common.MyException;
import org.csource.fastdfs.ClientGlobal;
import org.csource.fastdfs.StorageClient;
import org.csource.fastdfs.TrackerClient;
import org.csource.fastdfs.TrackerServer;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class FastdfsUtils {
/** fdfs初始化文件路径 **/
private Resource r = new ClassPathResource("fdfs_client.properties");
/** 日志**/
private final static Logger LOGGER = Logger.getLogger(FastdfsUtils.class);
/**
* 文件上传
* @throws MyException
* @throws IOException
* @throws FileNotFoundException
*/
public MapString, String fileUpLoad(boolean isEmpty, InputStream inputStream, String fileName)
throws Exception {
MapString, String map = new HashMapString, String();
if (isEmpty) {
throw new Exception("");
}
ClientGlobal.init(r.getFile().getAbsolutePath());
TrackerClient trackerClient = new TrackerClient();
TrackerServer trackerServer = trackerClient.getConnection();
StorageClient storageClient = new StorageClient(trackerServer, null);
byte[] file_buff = null;
if (inputStream != null) {
file_buff = new byte[inputStream.available()];
inputStream.read(file_buff);
}
String[] results = storageClient.upload_file(file_buff,
FilenameUtils.getExtension(fileName), null);
if (results == null) {
throw new Exception("");
}
map.put("fileType", FilenameUtils.getExtension(fileName));
map.put("original", fileName);
map.put("url", results[0] + "/" + results[1]);
map.put("state", "SUCCESS");
map.put("groupName", results[0]);
map.put("fileName", results[1]);
return map;
}
/**
* 文件下载
*/
public byte[] fileDownLoad(String groupName, String fileName) throws IOException, MyException {
ClientGlobal.init(r.getFile().getAbsolutePath());
TrackerClient trackerClient = new TrackerClient();
TrackerServer trackerServer = trackerClient.getConnection();
StorageClient storageClient = new StorageClient(trackerServer, null);
byte[] fileBytes = storageClient.download_file(groupName, fileName);
return fileBytes;
}
/**
* 文件删除
*/
public void fileDelete(String groupName, String fileName) throws FileNotFoundException,
IOException, MyException {
ClientGlobal.init(r.getFile().getAbsolutePath());
TrackerClient trackerClient = new TrackerClient();
TrackerServer trackerServer = trackerClient.getConnection();
StorageClient storageClient = new StorageClient(trackerServer, null);
storageClient.delete_file(groupName, fileName);
}
}
一个N位的十进制正整数，如果它的每个位上的数字的N次方的和等于这个数本身，则称其为花朵数。 例如： 当N
#includestring.h
#includemath.h
#include time.h
using namespace std;
void mc(int*b,int *a);
void f(int *s,int n);
void g(int *f,int *a);
int main()
{
int k=0;
int f1[10][21];
memset(f1,0,sizeof(f1));
int f2[10][21];
memset(f2,0,sizeof(f2));
int a[10],b[10];
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
int h[21];
memset(h,0,sizeof(h));
int y[21]={-1};
bool th =true;
for(int i=0;i10;i++)
{
f1[i][0]=i;
f(f1[i],21);
}
clock_t begin_time, end_time;
begin_time= clock();
for( a[0]=0;a[0]21;a[0]++)
for( a[1]=0;a[1]21-a[0];a[1]++)
for( a[2]=0;a[2]21-a[0]-a[1];a[2]++)
for( a[3]=0;a[3]21-a[2]-a[0]-a[1];a[3]++)
for( a[4]=0;a[4]21-a[3]-a[2]-a[1]-a[0];a[4]++)
for( a[5]=0;a[5]21-a[4]-a[3]-a[2]-a[1]-a[0];a[5]++)
for( a[6]=0;a[6]21-a[5]-a[4]-a[3]-a[2]-a[1]-a[0];a[6]++)
for( a[7]=0;a[7]21-a[6]-a[5]-a[4]-a[3]-a[2]-a[1]-a[0];a[7]++)
for( a[8]=0;a[8]21-a[7]-a[6]-a[5]-a[4]-a[3]-a[2]-a[1]-a[0];a[8]++)
{
a[9]=21-a[0]-a[1]-a[2]-a[3]-a[4]-a[5]-a[6]-a[7]-a[8];
if(a[9]=0||a[9]9)continue;
int gh;
for(int i=0;i10;i++)
{
gh=0;
for(int j=0;j21;j++)
{
int t=f1[i][j]*a[i]+gh;
f2[i][j]=t%10;
gh=t/10;
}
}
for(i=0;i10;i++)
{
g(f2[i],h);
}
mc(b,h);
for(i=0;i10;i++)
{
if(b[i]!=a[i])
{
th =false;
break;
}
}
if(th ==true)
{
/*coutendl;
for(i=0;i10;i++)
couta[i];
coutendl;
for(i=0;i10;i++)
coutb[i];
coutendl;*/
for(i=20;i=0;i--)
couth[i];
coutendl;
}
th =true;
memset(b,0,sizeof(b));
memset(h,0,sizeof(h));
memset(f2,0,sizeof(f2));
}
end_time = clock();
printf("\nTime elapsed:%.3lf (ms)\n",(double)(end_time-begin_time));
return 0;
}
void mc(int*b,int *a)
{
for(int i=0;i21;i++)
{
int n=a[i];
switch(n)
{
case 0:b[0]++;break;
case 1:b[1]++;break;
case 2:b[2]++;break;
case 3:b[3]++;break;
case 4:b[4]++;break;
case 5:b[5]++;break;
case 6:b[6]++;break;
case 7:b[7]++;break;
case 8:b[8]++;break;
case 9:b[9]++;break;
}
}
}
void f(int *s,int n)
{ int c=fabs(s[0]),h=0;
for(int i=0;i20;i++)
{ h=0;
for(int j=0;j21;j++)
{
int t=fabs(s[j])*c+h;
s[j]=t%10;
h=t/10;
}
}
}
void g(int *f,int *a)
{
int c=0;
for(int i=0;i21;i++)
{
int t=f[i]+a[i]+c;
a[i]=t%10;
c=t/10;
}
}
耗时55秒.....太慢了求改进.......
#include sstream
#include iostream
#include cstdlib
#include ctime
using namespace std;
templateclass T string tostring(T a){ostringstream os;osa;return os.str();}
#define N 21
typedef pairlong long,long long NUM;
#define MOD 1000000000000000LL;
NUM pow21[10][N+1];
int sump[10][N+1];
void init()
{
for(int i=0;i10;i++)
for(int j=0;j=N;j++)
sump[i][j]=i*j;
for(int i=0;i10;i++)
{
pow21[i][0].first=pow21[i][0].second=0;
}
pow21[0][1].first=pow21[0][1].second=0;
for(int i=1;i10;i++)
{
pow21[i][1].first=1;
pow21[i][1].second=0;
for(int j=0;jN;j++)
{
pow21[i][1].first*=i;
pow21[i][1].second*=i;
pow21[i][1].second+=pow21[i][1].first/MOD;
pow21[i][1].first%=MOD;
}
}
for(int j=2;j=N;j++)
{
for(int i=0;i10;i++)
{
pow21[i][j].first=j*pow21[i][1].first;
pow21[i][j].second=j*pow21[i][1].second;
pow21[i][j].second+=pow21[i][j].first/MOD;
pow21[i][j].first%=MOD;
}
}
}
int numct[10],numct2[10];
void print(NUM t)
{
string s=tostring(t.first);
s=string(15-s.size(),'0')+s;
coutt.secondsendl;
}
void check(NUM sum)
{
sum.second+=sum.first/MOD;
sum.first%=MOD;
if(sum.second100000||sum.second=1000000)return;
memset(numct2,0,sizeof(numct2));
long long t=sum.first;
for(int i=0;i15;i++)
{
numct2[t%10]++;
t/=10;
}
t=sum.second;
for(int i=0;i6;i++)
{
numct2[t%10]++;
t/=10;
}
if(memcmp(numct,numct2,sizeof(numct))==0)
print(sum);
}
void dfs(int k,int remain,NUM sum,int sum2)
{
if(k==2)
{
if((sum.first+sum.second-sum2)%9!=0)return;
}
if(k==0)
{
numct[0]=remain;
check(sum);
return;
}
NUM newsum;
for(numct[k]=remain;numct[k]=0;numct[k]--)
{
newsum.first=sum.first+pow21[k][numct[k]].first;
newsum.second=sum.second+pow21[k][numct[k]].second;
dfs(k-1,remain-numct[k],newsum,sum2+sump[k][numct[k]]);
}
}
int main()
{
int cl=clock();
init();
dfs(9,N,pairlong long,long long(),0);
cout"TIME::"clock()-cl"ms"endl;
cincl;
return 0;}
4S
java实现二进制穷举
闲着没事，给你写了一个一个DFS算法，可以枚举（a1, a2… ak），剩下的太简单，你自己写着玩吧。。。
import java.util.ArrayList;
public class DFS {
public static void main(String[] args) {
DFS dfs=new DFS();
dfs.dfs(1);
}
int sum=0;
int index=5;
ArrayListIntegerlist=new ArrayListInteger();
public void dfs(int i)
{
if(iindex)
{
sum++;
System.out.println("this is the "+sum);
for(Integer integer:this.list)
{
System.out.print(integer+" ");
}
System.out.println();
return;
}
for(int j=0;j=1;j++)
{
list.add(j);
this.dfs(i+1);
list.remove(list.size()-1);
}
}
}
分别用DFS和BFS算法给电脑设置AI(JAVA)
有必胜策略的吧。。状态空间的上限是3^9也就是不到20000实际上没有这么多。所以直接采用BFS标记会比较好。算法的话就是填充表，把表（九个格子）填为必胜、必败，己胜，开始的时候全部标为必败，再从胜状态开始向回BFS（或者DFS也可以），己胜状态向回标的一定是败状态，必胜状态的上一状态为必败态，必败态的上一状态可能是必败或者必胜（这就是因为这家伙走错棋了所以要输！）
我的习惯。不写代码。没有意思。
JAVA求10个景点间各个景点的最短路径 图随便话 距离随便 求代码
最有效，切不复杂的方法使用Breadth First Search (BFS). 基本代码如下（伪代码）。因为BFS不用递归，所以可能会有点难理解。
public Stack findPath(Vertex 起始景点, Vertex 目标景点){
Queue Vertex q = new QueueVertex();
s.enqueue(起始景点);
Vertex 当前位置;
while(!s.isEmpty()){
当前位置 = s.dequeue();
if (当前位置 == 目标景点) break;
for (每一个相邻于 当前位置 的景点 Vertex v){
if (!v.visited){
v.parent = 当前位置;
// 不是规定，不过可以节省一点时间
if (v == 目标景点){
current = v;
break;
}
s.enqueue(Vertex v);
v.visited = true;
}
}
}
Stack Vertex solution = new Stack Vertex();
Vertex parent = current;
while (parent != 起始景点){
solution.push(parent);
parent = current.parent;
}
for (graph中的每一个vertex) vertex.visited = false;
return solution(); // 其实这里建议用一个 Path 的inner class 来装所获得的路线
}
然后再 main 求每两个景点之间的距离即可
public static void main(String[] argv){
PathFinder pf = new PathFinder();
Stack[][] 路径 = new Stack[10][10];
for(int i=0; ipf.vertices.length; i++){
for(int j=i+1; jpf.vertices.length; j++){
Stack s = pf.findPath(pf.vertices[i], pf.vertices[j]);
路径[i][j] = s; 路径[j][i] = s; // 假设你的graph是一个undirected graph
}
}
// 这么一来就大功告成了！对于每两个景点n 与 m之间的最短路径就是在 stack[n][m] 中
}
还有一种方法就是用Depth First Search递归式的寻找路径，不过这样比较慢，而且我的代码可能会造成stack overflow
public Stack dfs(Vertex 当前景点，Vertex 目标景点){
if(当前景点 == 目标景点) return;
Stack solution = new Stack();
Stack temp;
for (相邻于 点钱景点 的每一个 Vertex v){
if (!v.visited){
v.visited = true;
temp = dfs(v, 目标景点);
// 抱歉，不记得是stack.size()还是stack.length()
if (solution.size() == 0) solution = temp;
else if(temp.size() solution.size()) solution = temp;
v.visited = false; 复原
}
}
return solution;
}
然后再在上述的Main中叫dfs...
参考：
java实现dfs的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于Java实现接口、java实现dfs的信息别忘了在本站进行查找喔。
发布于：2022-11-25，除非注明，否则均为原创文章，转载请注明出处。