Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Tabula contentorum

Floyd algorithmus

definition

Consuetudinem

Cautiones

Problem-solvenda notiones

In basic gradus

AcWing 343. Sorting

Quaeritur descriptio

currere codice

Code notiones

Improve ideas

Floyd algorithmus

definition

Algorithmus Floyd, plenum algorithmi Floyd-Warshalli nomen, est dynamica programmandi algorithmus usus ad solvendam quaestionem brevissimam inter omnia paria vertices in grapho. Idoneum est ad graphas directas ponderatas et ancipites ponderis negativi (non autem graphi ponderis cyclorum negativorum continentes), et deprehendere potest num ponderis cycli negativi sint in grapho.

Consuetudinem

1. Computet via brevissima inter omnia paria vertices: In campis ut analysis retis socialis, consilium retis translationis, et consilium retis communicationis, algorithmus Floyd optima electio est, cum brevissimum intervallum inter quaelibet duo puncta computare necesse est.
2. Deprehendere pondus negans cursus: In missionibus quibusdam applicationis cavendum est ne in graphe sint cycli ponderis negativi, sicut hoc indicare potest aliquem deprauationem vel errorem statum in systemate.

Cautiones

• memoria consummatio Spatium complexionis algorithmi Floyd est O(n^2), ubi n est numerus vertices in graph. Nam lacinia purus magna, id consequat turpis efficitur quis.
• tempus complexionem: Tempus complexionis algorithmi Floyd est O (n^ 3).
• negans pondus loop : Si pondus cycli negativum in graphe sit, algorithmus Floyd in ansam infinitam cadet, quia incipiens a nodo, via per hunc cyclum infinite reduci potest. In applicationibus adhibitis, huiusmodi condiciones primo deprehendi et pertractari necesse est.
• Algorithms cyclos pondus negans deprehendere potest:Si in executione algorithmi deprehenditur brevissimam viam a vertice ad se minorem esse quam 0, id est, D[i][i] < 0, saltem in grapha cycli ponderis negativi habeatur; et algorithmus hoc tempore rectam brevissimam exitum non potest reddere .
• Ad graphes amplissimas, magna difficultas et spatii complexitas algorithm potest fieri bottleneck.

Problem-solvenda notiones

Coro notio algorithmi Floyd programmatio dynamica est, cuius gradus fundamentales sunt hae:

1. Initialisatio: Pone spatium matricis D ad adiacentia matricis graphi, id est, D[i][j] = ponderis (i, j); D[i][j] = ∞;
2. Dynamic programmatio: K = 1 ad n, renovatio D ita ut D[i][j] = min(D[i][j], D[i][k] + D[k][j]), ut sit anglice num distantia ab i ad j possit per nodi k intermediam minui.
3. Consequuntur: Ultima D matrix brevissimam continet longitudinum viam inter omnia paria verticerum. Si certum D[i][j] <0 et i != j, et D[i][i] <0 occurrat in processu renovato, significat cyclum pondus negativum in grapho esse.

Exsecutio algorithmi Floyd triplicem ansam adhibet. Ansa exterior omnes vertices intermedios percurrit k, et duo interiora ansulae omnes binae vertex (i, j) ad reprimendam utrum via brevior sit.

In basic gradus

Ponamus nos graphi G ponderati habentes n vertices, duplici dimensione ordinatadist[][] brevissimam longitudinem inter binos vertices condere. Initio:dist[i][j]ponitur ad pondus marginem directe connexum in graphdist[i][j]Pone in infinitum (indicating unreachable).

1. initialization " : Crea n×n matrix D, ubi D[i][j] pondo marginis directi ab i ad j in graphum initialized, vel in infinitum pone, si nulla ora directa inter i et j. Elementum diametri D[i][i] = 0 .

2. dynamic programming : Uterque vertex k (ut vertex intermedius) iter brevissimam renovat inter singulas binas vertices i et j. Formula renovationis est: D[i][j] = min(D[i][j], D[i][k] + D[k][j]). Id est, si via ab i ad j brevior fiat per k ut vertex intermedia, renovatio D[i][j].

3. Exitus output: Post n orbes iterations, elementum D[i][j] quodlibet in matrice D est longitudo brevissima ab i ad j.

AcWing 343. Sorting

Quaeritur descriptio

343. Sorting - AcWing Quaeritur Bank

currere codice

#include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
 
#define PII pair<int, int>
#define fi first
#define se second
#define endl 'n'
map<int, int> mp;
 
const int N = 210, mod = 1e9 + 7;
int T, n, m, k;
int a[N], dist[N][N];
PII ans[N];
 
void floyd(int x) // 以 x 为中转点，更新其他点。
{
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            dist[i][j] = min(dist[i][j], dist[i][x] + dist[x][j]);
}
 
bool pd() // 判断是否所有点都已确定
{
    for (int i = 1; i <= n; i++) {
        int cnt = 0;
        for (int j = 1; j <= n; j++)
            if (dist[i][j] != 1e9)
                cnt++; // 当前点能到达的点数
        ans[i] = {cnt, i};
        for (int j = 1; j <= n; j++)
            if (i != j && dist[j][i] != 1e9)
                cnt++; // 能到达当前点的点数
        if (cnt != n)
            return 0;
    }
    sort(ans + 1, ans + n + 1);
    return 1;
}
 
int main() {
    while (cin >> n >> m && n) {
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                if (i != j)
                    dist[i][j] = 1e9;
 
        int flag = 0;
        for (int i = 1; i <= m; i++) {
            char a, t, b;
            cin >> a >> t >> b;
            int x = a - 'A' + 1, y = b - 'A' + 1; // 现在要加一条从 y 到 x 的边
 
            if (!flag && dist[x][y] != 1e9) // 发现已经从x能到y，出现矛盾
            {
                printf("Inconsistency found after %d relations.n", i);
                flag = 1;
            }
 
            dist[y][x] = 1;
            floyd(x), floyd(y); // 分别以 x 和 y 为中转点更新其他点
            if (!flag && pd()) { // 发现所有点都已确定
                printf("Sorted sequence determined after %d relations: ", i);
                for (int i = 1; i <= n; i++)
                    cout << char(ans[i].se + 'A' - 1);
                printf(".n");
                flag = 1;
            }
        }
        if (!flag)
            printf("Sorted sequence cannot be determined.n"); // 无法确定
    }
 
    return 0;
}

Code notiones

1. initialization ": uti adistDuo dimensiva ordinatio initialis est in infinitum, quae significat nullum ordinem certum inter inaequalitates per defaltam habitudinem.
2. Legere initus: Lege relationem a norma initus in forma "B > A", significans B meliorem esse quam A.
3. Relatio processus:
   • Cum nova relatio legatur, vide num aliqua sit contradictio (id est, certa relatio ante certas cum nova relatione).
   • renovaredistMatrix, algorithmo Floyd usus ad brevissimum iter inter omnes inaequalitates renovandum, hic actu adaequat relationem "prioritatis" vel "ordinationis".
4. Reprehendo genus certitudinem:
   • Compesce omnes inaequalitates se habere, i.e., quodlibet punctum attingere aliud punctum, et non est infinita via longitudo.
   • Si genus in processu legendi relationis inveniatur, vel genus adhuc definiri non potest, lectis omnibus relationibus, notitiae respondentes output erunt.

Improve ideas

• Emendationem efficientiam : Hodierna Floyd vocatio statim fit, postquam singulae novae relationes adduntur, quae necessariae esse non possunt. Exspectare potes donec omnes relationes lectae sint antequam algorithmum Floyd perficiat denuo ad calculos superfluos reducendos.
• Simpliciorem reddere logicam : Hodiernum codicem magis implicatum est in detectis contradictionibus et determinandis in logica voluptua complementum. Experiri potes logicam simpliciorem reddere, ut pluribus intuitivis notitiarum structurarum utendo vel gradibus algorithmicis ad has condiciones reprimendam.
• codice claritate: Claritas commentariorum et codicis structuram augere potest, codicem facilius intelligere et conservare.