java Floyd 三角形

Java中的Floyd三角形是一种特殊的数字三角形，它的每个位置上的数字是前一行相邻两个位置上的数字之和。以下是Java中实现Floyd三角形的代码示例：

import java.util.Scanner;

public class FloydTriangle {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要打印的行数：");
        int rows = scanner.nextInt();
        int number = 1;

        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(number + " ");
                number++;
            }
            System.out.println();
        }
    }
}

运行以上代码，你可以输入要打印的行数，然后程序会按照Floyd三角形的规律打印出相应行数的三角形。

相关问题

floyd算法java

Floyd算法，又称为插点法，是一种用于寻找给定的加权图中多源点之间最短路径的算法。下面是Floyd算法的Java实现：

public class FloydAlgorithm {
    private static final int INF = 999999; // 定义正无穷

    /**
     * Floyd算法实现
     * @param graph 图的邻接矩阵
     * @return 返回任意两个顶点之间的最短路径
     */
    public static int[][] floyd(int[][] graph) {
        int len = graph.length;
        int[][] dist = new int[len][len]; // 定义距离矩阵
        int i, j, k;

        // 初始化距离矩阵
        for (i = 0; i < len; i++) {
            for (j = 0; j < len; j++) {
                dist[i][j] = graph[i][j];
            }
        }

        // Floyd算法核心语句
        for (k = 0; k < len; k++) {
            for (i = 0; i < len; i++) {
                for (j = 0; j < len; j++) {
                    if (dist[i][k] + dist[k][j] < dist[i][j]) {
                        dist[i][j] = dist[i][k] + dist[k][j];
                    }
                }
            }
        }

        return dist;
    }

    public static void main(String[] args) {
        int[][] graph = {
                {0, 5, INF, 6, INF},
                {INF, 0, 4, INF, INF},
                {INF, INF, 0, 3, 7},
                {INF, INF, INF, 0, 4},
                {INF, INF, INF, INF, 0}
        };

        int[][] dist = floyd(graph);

        // 输出结果
        for (int[] row : dist) {
            System.out.println(Arrays.toString(row));
        }
    }
}

以上代码中，INF表示正无穷，也就是两点之间没有路径。在初始化距离矩阵时，直接将其初始化为图的邻接矩阵。接下来，通过三重循环遍历所有路径，如果经过中间点k比直接连接更短，则更新距离矩阵。最后返回任意两个顶点之间的最短路径矩阵。

Floyd pthread

根据提供的引用内容，没有提到Floyd pthread。但是可以根据Floyd算法的特点，使用多线程（pthread）来加速Floyd算法的执行。

Floyd算法的时间复杂度为O(N^3)，对于大规模的图来说，计算时间会非常长。因此，可以使用多线程来加速Floyd算法的执行。具体来说，可以将图分成若干个子图，每个子图分配一个线程来计算，最后将结果合并即可。

下面是一个使用pthread实现的Floyd算法的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define MAXN 1000
#define MAX_THREAD_NUM 4

int n, m;
int d[MAXN][MAXN];
int thread_num;

void *floyd(void *arg) {
    int k = *(int *)arg;
    int i, j, l;
    for (k = k * n / thread_num; k < (k + 1) * n / thread_num; k++) {
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                if (d[i][k] != -1 && d[k][j] != -1) {
                    if (d[i][j] == -1 || d[i][j] > d[i][k] + d[k][j]) {
                        d[i][j] = d[i][k] + d[k][j];
                    }
                }
            }
        }
    }
    return NULL;
}

void floyd_parallel() {
    pthread_t threads[MAX_THREAD_NUM];
    int i;
    for (i = 0; i < thread_num; i++) {
        int *arg = malloc(sizeof(int));
        *arg = i;
        pthread_create(&threads[i], NULL, floyd, arg);
    }
    for (i = 0; i < thread_num; i++) {
        pthread_join(threads[i], NULL);
    }
}

int main() {
    scanf("%d%d", &n, &m);
    int i, j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            if (i == j) {
                d[i][j] = 0;
            } else {
                d[i][j] = -1;
            }
        }
    }
    for (i = 0; i < m; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        d[u][v] = w;
    }
    scanf("%d", &thread_num);
    floyd_parallel();
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", d[i][j]);
        }
        printf("\n");
    }
    return 0;
}