leetode.599. Minimum Index Sum of Two Lists

Question

Suppose Andy and Doris want to choose a restaurant for dinner, and they both have a list of favorite restaurants represented by strings. 

You need to help them find out their common interest with the least list index sum. If there is a choice tie between answers, output all of them with no order requirement. You could assume there always exists an answer.

Example 1:

Input:
["Shogun", "Tapioca Express", "Burger King", "KFC"]
["Piatti", "The Grill at Torrey Pines", "Hungry Hunter Steakhouse", "Shogun"]
Output: ["Shogun"]
Explanation: The only restaurant they both like is "Shogun".

Example 2:

Input:
["Shogun", "Tapioca Express", "Burger King", "KFC"]
["KFC", "Shogun", "Burger King"]
Output: ["Shogun"]
Explanation: The restaurant they both like and have the least index sum is "Shogun" with index sum 1 (0+1).

Note:

1. The length of both lists will be in the range of [1, 1000].
2. The length of strings in both lists will be in the range of [1, 30].
3. The index is starting from 0 to the list length minus 1.
4. No duplicates in both lists.

Solution

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
char** findRestaurant(char** list1, int list1Size, char** list2, int list2Size, int* returnSize) {
    
    int i,j,sum=list1Size+list2Size-2,index=0;
    int n = list1Size > list2Size ? list1Size : list2Size;
    char **str = (char**)malloc(n * sizeof(char *));
    
    for (i = 0; i < list1Size; i++) {
        for (j = 0; j < list2Size; j++) {
            if (strcmp(list1[i], list2[j]) == 0) {
                if (i+j <= sum) {
                    sum = i + j;
                    *(str+index) = (char)malloc(sizeof(char));
                    *(str+index) = list1[i];
                    index++;
                }
                break;
            }
        }
    }
    
    *returnSize = index;
    
    return str;
}

Solution with hash map (别人的最优解)

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
#include <string.h>

#define HASHKEY 0xFF
#define NAMESIZEALIGN8 0x20
#define DEBUG 0

char** findRestaurant(char** list1, int list1Size, char** list2, int list2Size, int* returnSize) {
    typedef struct hash_struct {
        char *name;
        int index;
        struct hash_struct *next;
    }hashs;
    
    int hindex, i, j, anssum = list1Size + list2Size, max;
    hashs *hashmap[HASHKEY + 1], *hcur;
    char ans[list1Size + list2Size][31], *acur, **ans_test;
    
    for (i = 0; i < HASHKEY + 1; i++)
        hashmap[i] = NULL;
    
    for (i = 0; i < list1Size; i++) {
        hindex = (list1[i][0] + list1[i][1]) & HASHKEY;
        hcur = malloc(sizeof(hashs));
        hcur->name = list1[i];
        hcur->index = i;
        if (hashmap[hindex])
            hcur->next = hashmap[hindex];
        else
            hcur->next = NULL;
        hashmap[hindex] = hcur;
    }

    for (i = 0; i < list2Size; i++) {
        hindex = (list2[i][0] + list2[i][1]) & HASHKEY;
        hcur = hashmap[hindex];
        while (hcur) {
            if (strcmp(list2[i], hcur->name))
                hcur = hcur->next;
            else {
                if (hcur->index + i < anssum) {
                    anssum = hcur->index + i;
                    *returnSize = 1;
                    strcpy(ans[0], list2[i]);
                } else if (hcur->index + i == anssum) {
                    j = *returnSize;
                    strcpy(ans[j], list2[i]);
                    (*returnSize)++;
                }
                break;
            }
        }
    }
    
    if (*returnSize) {
        max = *returnSize;
        ans_test = malloc(max * sizeof(char *));
        for (i = 0; i < max; i++) {
            ans_test[i] = malloc(NAMESIZEALIGN8 * sizeof(char));
            strcpy(ans_test[i], ans[i]);
        }
        return ans_test;
    }
    return NULL;
}