分枝定界法搜索SPN结构的最优差分特征（以PRESENT64为例）

已于 2023-12-26 20:30:04 修改
阅读量64 收藏 1
点赞数 1
分类专栏： 密码学 文章标签： 算法 c语言 密码学
于 2023-12-23 14:24:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45851672/article/details/135168363
版权 
#define printf __mingw_printf
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>

#define R 10      // 定义算法轮数
#define N 16      // 定义s盒个数
#define s_in_L 4  // 定义s盒输入比特
#define s_out_L 4 // 定义s盒输出比特
#define L (1 << (s_in_L + s_out_L))
#define L1 (1 << s_in_L)
#define L2 (1 << s_out_L)
#define base (L2 - 1)

int Rr;
long double DiffP[R][N]; // 每轮的差分概率
int Alpha[R][N];         // 每轮的输入差分
int Beta[R][N];          // 每轮的输出差分
int maxAlpha[R][N];      // 每轮的最优输入差分
int maxBeta[R][N];       // 每轮的最优输出差分
long double Pestim;
int flag;
long double all_sbdiff_p[N][L]; // 所有s盒的差分概率
long double pn_sb[N];           // n个s盒的最优概率
long double Pbest[R];           // 每轮的最优概率
int actIndex[R][N];             // 活跃s盒的下标
int actIndexLength[R];          // 活跃s盒的个数
long double sboxdiffprobability[L];
int maxbacktable[N][L2];
int maxforwardtable[N][L1];
int *combian;
int *combianSize;
int combianIndex = 0;
int data[N];
long double *arr;
int decreasort[L1][L2];
int pbox[64] = {0, 16, 32, 48, 1, 17, 33, 49, 2, 18, 34, 50, 3, 19, 35, 51, 4, 20, 36, 52, 5, 21, 37, 53, 6, 22, 38, 54, 7, 23, 39, 55, 8, 24, 40, 56, 9, 25, 41, 57, 10, 26, 42, 58, 11, 27, 43, 59, 12, 28, 44, 60, 13, 29, 45, 61, 14, 30, 46, 62, 15, 31, 47, 63};

void Round(int r);
void SubRound(int r, int n);
void FirstRound(int M[], int n);
void init();
void calculateDifferential();
void all_sbdiff_pfun();
void Decreasesort();
void maxback();
void maxforward();
void pn_sbfun();
void calculateCombianAndCombianSize();
void generateCombinations(int n, int start, int *buffer, int bufferIndex);
int sumcombian(int n);
void activesbox(int begin, int end);
void update(int begin, int end);
long double product(int begin, int end);
long double fmaxfun(long double data[], int begin, int end);
void sortDoubleArray(long double array[], int size);
void sort_indices(long double *array, int *indices, int n);
int compare1(const void *a, const void *b);
int compare2(const void *a, const void *b);
void pboxfun(int *data);
long double LastRound();
int OptTrailSearch(long double Pestim);
long double OptTrail();
int compare1(const void *a, const void *b)
{
    int index1 = *(int *)a;
    int index2 = *(int *)b;
    if (arr[index1] < arr[index2])
        return 1;
    if (arr[index1] > arr[index2])
        return -1;
    return 0;
}
int compare2(const void *a, const void *b)
{
    long double arg1 = *(const long double *)a;
    long double arg2 = *(const long double *)b;
    if (arg1 < arg2)
        return -1;
    if (arg1 > arg2)
        return 1;
    return 0;
}
void sortDoubleArray(long double array[], int size)
{
    qsort(array, size, sizeof(long double), compare2);
}
long double fmaxfun(long double data[], int begin, int end)
{
    long double max = data[begin];
    for (int i = begin; i <= end; i++)
    {
        if (data[i] > max)
        {
            max = data[i];
        }
    }
    return max;
}
void sort_indices(long double *array, int *indices, int n)
{
    arr = array; // 设置全局变量
    for (int i = 0; i < n; i++)
    {
        indices[i] = i;
    }
    qsort(indices, n, sizeof(int), compare1);
}
void generateCombinations(int n, int start, int *buffer, int bufferIndex)
{
    if (bufferIndex == n)
    {
        for (int i = 0; i < n; i++)
        {
            combian[combianIndex++] = buffer[i];
        }
        return;
    }
    for (int i = start; i < N; i++)
    {
        buffer[bufferIndex] = i;
        generateCombinations(n, i + 1, buffer, bufferIndex + 1);
    }
}
void calculateCombianAndCombianSize()
{
    int totalSize = N * (1 << (N - 1));        // 计算combian的总大小
    combian = malloc(totalSize * sizeof(int)); // 分配combian的大小
    combianSize = malloc(N * sizeof(int));     // 存储每个n的组合数
    int prevIndex = 0;                         // 用于计算每个n的组合数
    for (int n = 1; n <= N; n++)
    {
        int *buffer = malloc(n * sizeof(int));
        generateCombinations(n, 0, buffer, 0);
        combianSize[n - 1] = (combianIndex - prevIndex) / n; // 存储n的组合数
        prevIndex = combianIndex;                            // 更新prevIndex
        free(buffer);
    }
}
int sumcombian(int n)
{
    int sum = 0;
    if (n == 1)
    {
        return 0;
    }
    for (int i = 0; i < n - 1; i++)
    {
        sum = sum + (i + 1) * combianSize[i];
    }
    return sum;
}
void init()
{
    for (int i = 0; i < R; i++)
    {
        for (int j = 0; j < N; j++)
        {
            Alpha[i][j] = 0;
            Beta[i][j] = 0;
            DiffP[i][j] = 1.0;
            actIndex[i][j] = j;
        }
        actIndexLength[i] = N;
    }
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < L; j++)
        {
            all_sbdiff_p[i][j] = 0.0;
        }
    }
}
int sbox[L1] = {0xC, 0x5, 0x6, 0xB, 0x9, 0x0, 0xA, 0xD, 0x3, 0xE, 0xF, 0x8, 0x4, 0x7, 0x1, 0x2};
void sboxfun(int *data)
{
    for (int i = 0; i < (1 << L1); i++)
    {
        data[i] = sbox[data[i]];
    }
}
long double calculateDifferentialProbability(int inputDiff, int outputDiff)
{
    int count = 0;
    for (int x = 0; x < L1; x++)
    {
        int y = x ^ inputDiff;
        if (outputDiff == (sbox[x] ^ sbox[y]))
            count++;
    }
    long double probability = (long double)count / L1;
    return probability;
}
void calculateDifferential()
{
    for (int i = 0; i < L1; i++)
    {
        for (int j = 0; j < L2; j++)
        {
            sboxdiffprobability[i * L1 + j] = calculateDifferentialProbability(i, j);
        }
    }
}
void all_sbdiff_pfun()
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < L; j++)
        {
            all_sbdiff_p[i][j] = sboxdiffprobability[j];
        }
    }
}
long double product(int begin, int end)
{
    long double p = 1.0;
    for (int i = begin - 1; i < end; i++)
    {
        for (int j = 0; j < actIndexLength[i]; j++)
        {
            p = p * DiffP[i][actIndex[i][j]];
        }
    }
    return p;
}
void update(int begin, int end)
{
    int index1, index2;
    for (int r = begin - 1; r < end; r++)
    {
        for (int i = 0; i < actIndexLength[r]; i++)
        {
            index1 = actIndex[r][i];
            index2 = Beta[r][index1] + Alpha[r][index1] * L2;
            DiffP[r][index1] = all_sbdiff_p[index1][index2];
        }
    }
}
void activesbox(int begin, int end)
{
    for (int r = begin - 1; r < end; r++)
    {
        int count = 0;
        for (int i = 0; i < N; i++)
        {
            if (Alpha[r][i] != 0)
            {
                actIndex[r][count] = i;
                count++;
            }
        }
        actIndexLength[r] = count;
    }
}
void Decreasesort()
{
    long double array[L2];
    int *indices = malloc(L2 * sizeof(int)); // 索引数组
    for (int i = 0; i < L1; i++)
    {
        for (int j = 0; j < L2; j++)
        {
            array[j] = sboxdiffprobability[i * L1 + j];
        }
        sort_indices(array, indices, L2);
        for (int k = 0; k < L2; k++)
        {
            decreasort[i][k] = indices[k];
        }
    }
    free(indices);
}
void pn_sbfun()
{
    long double temp[N];
    for (int i = 0; i < N; i++)
    {
        temp[i] = fmaxfun(sboxdiffprobability, (1 << s_out_L), L - 1);
    }
    sortDoubleArray(temp, N);
    pn_sb[0] = temp[N - 1];
    for (int i = 1; i < N; i++)
    {
        pn_sb[i] = pn_sb[i - 1] * temp[N - i - 1];
    }
}
void maxback()
{
    for (int sbox_index = 0; sbox_index < N; sbox_index++)
    {
        for (int beta = 0; beta < L2; beta++)
        {
            int alpha = 0;
            long double pmax = 0;
            for (int i = 0; i < L1; i++)
            {
                if (all_sbdiff_p[sbox_index][i * L2 + beta] >= pmax)
                {
                    alpha = i;
                    pmax = all_sbdiff_p[sbox_index][beta + i * L2];
                }
            }
            maxbacktable[sbox_index][beta] = alpha;
        }
    }
    return;
}
void maxforward()
{
    for (int sbox_index = 0; sbox_index < N; sbox_index++)
    {
        for (int alpha = 0; alpha < L1; alpha++)
        {
            int beta = 0;
            long double pmax = 0;
            for (int i = 0; i < (1 << s_out_L); i++)
            {
                if (all_sbdiff_p[sbox_index][i + alpha * L1] >= pmax)
                {
                    beta = i;
                    pmax = all_sbdiff_p[sbox_index][i + alpha * L1];
                }
            }
            maxforwardtable[sbox_index][alpha] = beta;
        }
    }
    return;
}
void pboxfun(int *data)
{
    int bits[64];
    for (int i = 0; i < 16; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            bits[i * 4 + j] = (data[i] >> (3 - j)) & 1;
        }
    }
    int temp[64];
    for (int i = 0; i < 64; i++)
    {
        temp[i] = bits[i];
    }
    for (int i = 0; i < 64; i++)
    {
        bits[pbox[i]] = temp[i];
    }
    for (int i = 0; i < 16; i++)
    {
        data[i] = 0;
        for (int j = 0; j < 4; j++)
        {
            data[i] |= bits[i * 4 + j] << (3 - j);
        }
    }
}
long double LastRound()
{
    if (actIndexLength[Rr - 1] > 0)
    {
        int index1 = 0, index2 = 0;
        for (int i = 0; i < N; i++)
        {
            Beta[Rr - 1][i] = 0;
        }
        for (int i = 0; i < actIndexLength[Rr - 1]; i++)
        {
            index1 = actIndex[Rr - 1][i];
            Beta[Rr - 1][index1] = maxforwardtable[index1][Alpha[Rr - 1][index1]];
        }
        long double p = 1.0;
        int m;
        for (int i = 0; i < Rr; i++)
        {
            for (int j = 0; j < actIndexLength[i]; j++)
            {
                index1 = actIndex[i][j];
                index2 = Beta[i][index1] + Alpha[i][index1] * L2;
                p = p * all_sbdiff_p[index1][index2];
            }
        }
        if (p >= Pestim)
        {
            flag = 0;
            Pestim = p;
            activesbox(1, Rr);
            for (int i = 0; i < Rr; i++)
            {
                for (int j = 0; j < N; j++)
                {
                    maxAlpha[i][j] = Alpha[i][j];
                    maxBeta[i][j] = Beta[i][j];
                }
            }
        }
    }
    else
    {
        printf("全0 error\n");
    }
}
void Round(int r)
{
    for (int i = 0; i < N; i++)
    {
        Beta[r - 1][i] = 0;
    }
    activesbox(1, r);
    SubRound(r, 1);
}
void SubRound(int r, int n)
{
    if (n > actIndexLength[r - 1])
    {

        // 这里不用像论文一样把概率赋值,因为在每次改变值时都已经更新了概率
        int data[N];
        for (int i = 0; i < N; i++)
        {
            data[i] = Beta[r - 1][i];
        }
        pboxfun(data); // 线性变换
        for (int i = 0; i < N; i++)
        {
            Alpha[r][i] = data[i];
        }
        activesbox(1, r + 1);
        update(1, r + 1);

        if (r + 1 < Rr)
        {
            Round(r + 1);
        }
        else
        {
            LastRound();
        }
    }
    else
    {
        for (int i = 0; i < L2; i++)
        {
            Beta[r - 1][actIndex[r - 1][n - 1]] = decreasort[Alpha[r - 1][actIndex[r - 1][n - 1]]][i];
            long double p = 1;
            for (int j = 0; j < n; j++)
            {
                p = p * all_sbdiff_p[actIndex[r - 1][j]][Beta[r - 1][actIndex[r - 1][j]] + Alpha[r - 1][actIndex[r - 1][j]] * L2];
            }
            for (int i = 0; i < r - 1; i++)
            {
                for (int j = 0; j < actIndexLength[i]; j++)
                {
                    p = p * all_sbdiff_p[actIndex[i][j]][Beta[i][actIndex[i][j]] + Alpha[i][actIndex[i][j]] * L2];
                }
            }
            p = p * Pbest[Rr - r - 1];
            if (actIndexLength[r - 1] > n)
            {
                p = p * pn_sb[actIndexLength[r - 1] - n - 1];
            }
            if (p < Pestim)
            {
                break;
            }
            int data[N];
            for (int i = 0; i < N; i++)
            {
                data[i] = Beta[r - 1][i];
            }
            pboxfun(data); // 线性变换
            int sum = 0;
            for (int i = 0; i < 16; i++)
            {
                if (data[i] != 0)
                {
                    sum++;
                }
            }
            p = p * pn_sb[sum - 1];
            if (Rr > r + 1)
            {
                p = p * Pbest[Rr - r - 2];
            }
            if (p < Pbest[Rr - r - 1] * Pestim)
            {
                break;
            }

            else
            {
                update(r, r);
                activesbox(1, r);
                SubRound(r, n + 1);
            }
        }
    }
    return;
}
void FirstRound(int M[], int n)
{
    int sbox_index;
    for (int i = 0; i < n; i++)
    {
        sbox_index = M[i];
        Alpha[0][sbox_index] = maxbacktable[sbox_index][Beta[0][sbox_index]];
    }
    for (int i = 0; i < N; i++)
    {
        data[i] = Beta[0][i];
    }
    pboxfun(data); // 线性变换
    for (int i = 0; i < N; i++)
    {
        Alpha[1][i] = data[i];
    }
    if (Rr > 2)
    {
        activesbox(1, 2);
        update(1, 1);
        Round(2);
    }
    else
    {
        for (int i = 0; i < N; i++)
        {
            Beta[Rr - 1][i] = 0;
        }
        activesbox(1, Rr);
        LastRound();
    }
    return;
}
int OptTrailSearch(long double Pestim) // r大于等于2
{
    int begin;
    long limit;
    long temp;
    for (int n = 1; n < N + 1; n++)
    {
        if (pn_sb[n - 1] * Pbest[Rr - 2] < Pestim)
        {
            break;
        }
        else
        {
            for (int i = 0; i < N; i++)
            {
                Beta[0][i] = 0;
                Alpha[0][i] = 0;
            }
            begin = sumcombian(n);
            int M[n];
            for (int i = 0; i < combianSize[n - 1]; i++)
            {
                for (int j = 0; j < n; j++)
                    M[j] = combian[begin + n * i + j];
            }
            limit = powl(base, n);
            for (long k = 0; k < limit; k++)
            {
                temp = k;
                for (int index = 0; index < n; index++)
                {
                    Beta[0][M[index]] = temp % base + 1;
                    temp = temp / base;
                }
                FirstRound(M, n);
            }
        }
    }
    return flag;
}
long double OptTrail()
{
    Pestim = Pbest[Rr - 2] * pn_sb[0];
    flag = -1;
    flag = OptTrailSearch(Pestim);
    while (1)
    {
        if (~flag)
        {
            break;
        }
        else
        {
            Pestim = Pestim / 2;
            OptTrailSearch(Pestim);
        }
    }
    return Pestim;
}
int main()
{
    init();
    calculateDifferential();
    all_sbdiff_pfun();
    Decreasesort();
    maxback();
    maxforward();
    calculateCombianAndCombianSize();
    pn_sbfun();
    Pbest[0] = pn_sb[0];

    clock_t start, end;
    double cpu_time_used = 0;

    for (Rr = 2; Rr < R + 1; Rr++)
    {
        start = clock();
        Pbest[Rr - 1] = OptTrail();
        end = clock();
        cpu_time_used = cpu_time_used + ((double)(end - start)) / (CLOCKS_PER_SEC / 1000);
        printf("%d轮 最优差分特征:\n", Rr);
        for (int i = 0; i < Rr; i++)
        {
            for (int j = 0; j < N; j++)
            {
                printf("%d ", maxAlpha[i][j]);
            }
            printf("\n");
            for (int j = 0; j < N; j++)
            {
                printf("%d ", maxBeta[i][j]);
            }
            printf("\n");
        }
    }
    // 输出Pbest
    printf("最优差分转移概率:\n");
    for (int i = 1; i < R; i++)
    {
        printf("%Le ", Pbest[i]);
    }
    printf("\n%d轮程序运行时间: %g ms\n", R, cpu_time_used);
    free(combian);
    free(combianSize);
    return 0;
}

上述算法原理参考自论文《Automatic Search for a Maximum Probability Differential Characteristic in a Substitution-Permutation Network》

梦想花终开
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spn线性差分分析
09-06
写的东西比较繁琐，请各位大神多多指教！很多存在漏洞的地方请谅解
AES攻击方法 ：差分密码分析 boomerang attack飞去来器攻击
m0_67105022的博客
03-20 2695
AES具有123比特的分组长度，三种可选的密钥长度（128，192，256） AES是一个迭代型密码，轮数依赖于密钥长度。如果密钥长度为128比特，则轮数为10；如果密钥长度为192比特，则轮数为12；如果密钥长度为256比特，则轮数为14； 混淆（Confusion） 混淆是为了让密钥与密文的统计信息之间的关系变得复杂，从而增加通过统计方法进行攻击的难度。混淆可以通过各种代换算法实现，如S盒、乘法（加）与异或等运算组合，为非线性部件。 扩散（Diffusion） 扩散是为了让明文的单个比特影像到
SPN结构的作用
weixin_35756690的博客
12-26 462
SPN(Sum-Product Network)是一种用来表示复杂概率分布的结构。它是一种由许多节点构成的图形结构，其中节点可以分为两种类型：叶节点和内部节点。叶节点表示某个变量的取值，而内部节点表示某些变量之间的概率关系。 SPN 结构的主要作用是用来表示复杂的概率分布，这些概率分布可以是任意形式的，例如连续的或离散的。SPN 结构可以帮助我们对概率分布进行更好的理解和推断，并且可以用来进行贝叶...
差分
热门推荐
weixin_43255133的博客
11-04 1万+
一．差分攻击的背景 差分攻击是由Biham和Shamir于1991年提出的选择明文攻击方法，它的提出时间甚至比DES的设计要早十年。它是针对分组密码攻击最有效的方法之一。差分攻击通过分析特定明文差分对相对应密文差分的影响来提取密钥。差分分析现在被广泛应用于各种分组密码的攻击。 分组加密的轮数对差分分析的影响比较大。如果DES只是使用8轮的话，则在个人计算机上只需要几分钟就可以破译。但要是在完全的1...
c语言spn线性分析,线性分析法
weixin_39719729的博客
05-22 1865
0x00 概述线性分析法、差分分析法作为SPN(Substitution Permutation Network)的常用解法，一直让密码学家痴迷。最近也因为0ctf的一些密码学题目，对线性分析法有了一定的了解，并想写篇博客将具体内容详细展示！0x01 SPN网络介绍首先我们来看看这个spn网络每轮都包含3个步骤：substitution(代替)、permutation(置换)、key-mixing...
差分密码分析
I Hsien's BLOG
08-19 6705
差分密码分析是针对SPN结构中的S盒(通过测试可以探测出结构)进行分析的方法,最后目标是破解出异或密钥k. 准备工作 对于一个4位一组的S盒的输入xxx输出yyy输入x∗x^*x∗输出y∗y^*y∗, 计差分为x′=x⊕x∗x&#x27;=x\oplus x^*x′=x⊕x∗,y′=y⊕y∗y&#x27;=y\oplus y^*y′=y⊕y∗. 则4位下x′x&#x27;x...
华科密码学课设之SPN的差分攻击以及暴力破解算法
09-13
华科密码学课设之SPN的查分攻击以及暴力破解算法。差分攻击算法只能攻击出2个子密钥，其余的6个子密钥已经通过穷举法攻击破解得到。
论文研究-Midori64的相关密钥不可能差分分析.pdf
07-22
Midori算法是由Banik等人在AISACRYPT2015上提出的一种具有SPN结构的轻量级的加密算法。Midori的分组长度有64 bit和128 bit两种，分别为Midori64和Midori128。对Midori64进行研究，目前攻击者已经使用了不可能差分...
密码学代码完整版密码学代码完整版
01-21
SPN算法实现、线性分析、差分分析、SPN增强、RSA参数计算、模重复平方、中国剩余定理、蒙哥马利、PKCS#7、彩虹表
SPN线性密码分析
07-13
密码学作业2（分组密码与高级加密标准） C语言实现SPN线性密码分析 密码学作业2（分组密码与高级加密标准） C语言实现SPN线性密码分析
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
未来就在脚下。
05-20 493
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
MT2057 门票
l141930402的博客
05-15 758
前缀和+归并排序
力扣62 不同路径 Java版本
最新发布
m0_47066863的博客
05-20 185
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。从左上角开始，总共有 3 条路径可以到达右下角。题目数据保证答案小于等于 2 * 109。输入：m = 3, n = 7。输入：m = 3, n = 2。输入：m = 7, n = 3。输入：m = 3, n = 3。问总共有多少条不同的路径？
技艺高超的魔法师：Java运算符
epitomizelu的专栏
05-14 788
Java运算符是构建复杂程序的基础，掌握它们的使用和优先级对于写出高效、清晰的代码至关重要。通过本文的介绍和实例，希望能帮助读者更好地理解和运用这些运算符，让代码表达更加精准和高效。记住，实践是学习的最好方式，不断编写代码并探索不同的场景，你会越来越熟练地掌握它们。
22. 括号生成
编程SHARE的博客
05-20 175
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
算法模块方法总结（数组）
Cobrander2_0的博客
05-17 146
二分查找（Binary Search）是一种在有序数组（必须是不能重复的，因为如果有重复的，会从几个符合的选项中输出一个，可能不合题意）中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。二分查找的思想是便于理解的，但是边界条件是很容易写错的。比如下面的。
常见加解密算法03 - RC4逆向认识
a5right的博客
05-14 961
各位聪明绝顶，才高八斗的读者们你们好！今天我们主要讨论编译之后的RC4算法识别。题外话，之前看到一个蛋疼的小知识，说“势”这个字最好不好查词典释义。我是很好奇的，果然后来无法直视势不可挡这个成语。言归正传，我们将上一篇的Java与C的代码都编译一下，分别反编译看看。
数据结构复习指导之图的最短路径（Dijkstra算法和Floyd算法）
心碎烤肠的博客
05-20 754
本节是历年考查的重点。图的应用主要包括:最小生成(代价)树、最短路径、拓扑排序和关键路径。一般而言，这部分内容直接以算法设计题形式考查的可能性极小，而更多的是结合图的实例来考查算法的具体操作过程，读者必须学会手工模拟给定图的各个算法的执行过程。此外，还需掌握对给定模型建立相应的图去解决问题的方法。
电力系统潮流计算的计算机算法（三）——牛顿-拉夫逊潮流算法
Vast Skies的博客
05-15 787
本篇为本科课程《电力系统稳态分析》的笔记。本篇为这一章的第三篇笔记。主要介绍极坐标形式的牛顿-拉夫逊潮流算法
对于采用 SPN 结构的密码算法, 如果扩散层为简单的比特置换，单比特输入差分能引起单比特输出差分的差分特征个数如何计算
06-12
对于采用SPN结构的密码算法，如果扩散层为简单的比特置换，单比特输入差分能引起单比特输出差分的差分特征个数可以通过计算扩散层比特置换矩阵的秩来得到。 具体地，假设扩散层的比特置换矩阵为 $P$，$P$ 的行数和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梦想花终开

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值