2021.4.13（801/802/804）

2021.4.13

801.使序列递增的最小交换次数

int minSwap(int *A, int ASize, int *B, int BSize)
{
    int i;
    int dp[ASize][ASize];
    for (int i = 0; i < ASize; i++)
    {
        for (int j = 0; j < BSize; j++)
        {
            dp[i][j] = 0;
        }
    }

    //初始化；表示第一个元素交换和不交换
    dp[0][0] = 0;
    dp[0][1] = 1;

    for (int i = 1; i < ASize; i++)
    {
        if (A[i - 1] < A[i] && B[i - 1] < B[i])
        {
            if (A[i - 1] < B[i] && B[i - 1] < A[i]) //可交换，可不交换
            {
                dp[i][0] = Mmin(dp[i - 1][0], dp[i - 1][1]);
                dp[i][1] = Mmin(dp[i - 1][0], dp[i - 1][1]) + 1;
            }
            else //不能交换
            {
                dp[i][0] = dp[i - 1][0];
                dp[i][1] = dp[i - 1][1] + 1;
            }
        }
        else //必须交换
        {
            dp[i][0] = dp[i - 1][1];
            dp[i][1] = dp[i - 1][0] + 1;
        }
    }
    return Mmin(dp[ASize - 1][0], dp[ASize - 1][1]);
}

804. 唯一的摩尔斯密码词

int uniqueMorseRepresentations(char **words, int wordsSize)
{
    const char mima[][5] = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};
    int cnt = 0;
    char hush[100][50];
    char str[50];
    memset(hush, 0, sizeof(hush));

    for (int i = 0; i < wordsSize; ++i)
    {
        int len = 0;
        int j = 0;
        for (j = 0; words[i][j] != '\0'; ++j)
        {
            for (int k = 0; mima[words[i][j] - 'a'][k] != '\0'; ++k)
            {
                str[len++] = mima[words[i][j] - 'a'][k];
            }
        }
        str[len] = '\0';
        for (j = 0; j < cnt; ++j)
        {
            if (strcmp(hush[j], str) == 0)
            {
                break;
            }
        }
        if (j == cnt)
        {
            strcpy(hush[cnt++], str);
        }
    }
    return cnt;
}

812.最大三角形面积

inline double getLength(int *point1, int *point2)
{
    return sqrt((point1[0] - point2[0]) * (point1[0] - point2[0]) +
                (point1[1] - point2[1]) * (point1[1] - point2[1]));
}

double largestTriangleArea(int **points, int pointsSize, int *pointsColSize)
{
    int i, j, k;

    double a;
    double b;
    double c;
    double p;
    double s;
    double ret;

    for (i = 0; i < pointsSize - 2; i++)
    {
        for (j = i + 1; j < pointsSize - 1; j++)
        {
            for (k = j + 1; k < pointsSize; k++)
            {
                a = getLength(points[i], points[j]);
                b = getLength(points[i], points[k]);
                c = getLength(points[j], points[k]);

                p = (a + b + c) / 2;
                s = sqrt(p * (p - a) * (p - b) * (p - c));
                ret = ret < s ? s : ret;
            }
        }
    }

    return ret;
}