要在字符串中找到最长的无重复字符的子串，可以使用滑动窗口技术。滑动窗口通过两个指针来表示当前窗口的起始和结束位置，并且维护一个哈希表来记录字符及其最后出现的位置，以此来确保字符不重复。
以下是用C语言实现的代码：
#include#include #define MAX_CHARS 256 int longestUniqueSubsttr(char *str) { int n = strlen(str); int current_len = 1; // 当前子串的长度 int max_len = 1; // 结果 int prev_index; //前一个索引 int *visited = (int *)malloc(sizeof(int) * MAX_CHARS); for (int i = 0; i < MAX_CHARS; i++) { visited[i] = -1; } visited[(int)str[0]] = 0; for (int i = 1; i < n; i++) { prev_index = visited[(int)str[i]]; if (prev_index == -1 || i - current_len > prev_index) { current_len++; } else { if (current_len > max_len) { max_len = current_len; } current_len = i - prev_index; } visited[(int)str[i]] = i; } if (current_len > max_len) { max_len = current_len; } free(visited); return max_len; } int main() { char str[] = "abcabcbb"; printf("最长无重复字符子串的长度是 %d\n", longestUniqueSubsttr(str)); return 0; }
初始化：
visited 数组用于存储每个字符的最后出现位置，大小为 MAX_CHARS（ASCII 字符集）。
初始化 visited 数组为 -1，表示所有字符初始时都未出现过。
遍历字符串：
对于每个字符，检查它是否在当前窗口内已出现。
使用 prev_index 保存字符上次出现的位置。
如果字符未出现或者不在当前窗口内，当前窗口长度 current_len 加 1。
如果字符在当前窗口内已出现，更新最大长度 max_len，并重置 current_len 为当前窗口的新长度。
更新哈希表：
更新当前字符在 visited 中的位置。
返回结果：
返回最长无重复字符子串的长度。
这个算法的时间复杂度是 O(n)，因为每个字符在最坏情况下也只会被访问两次（一次被加入窗口，一次被移出窗口），空间复杂度是 O(1)，因为 visited 数组的大小是固定的。
为了找到给定数组中出现频率最高的前n个数，我们需要以下步骤：
统计每个元素的出现次数：使用一个哈希表（可以用C语言中的结构体数组来实现）。
将元素及其出现次数存储在一个结构体数组中。
对结构体数组按出现次数进行排序。
输出前n个频率最高的元素。
下面是完整的C语言实现代码：
#include#include typedef struct { int value; int count; } ElementCount; int compare(const void *a, const void *b) { ElementCount *elemA = (ElementCount *)a; ElementCount *elemB = (ElementCount *)b; return elemB->count - elemA->count; } void findTopNFrequent(int arr[], int size, int n) { ElementCount *elementCounts = malloc(size * sizeof(ElementCount)); int distinctElements = 0; // 初始化元素计数器 for (int i = 0; i < size; i++) { elementCounts[i].value = 0; elementCounts[i].count = 0; } // 统计每个元素的出现次数 for (int i = 0; i < size; i++) { int found = 0; for (int j = 0; j < distinctElements; j++) { if (elementCounts[j].value == arr[i]) { elementCounts[j].count++; found = 1; break; } } if (!found) { elementCounts[distinctElements].value = arr[i]; elementCounts[distinctElements].count = 1; distinctElements++; } } //按照出现次数降序排序元素 qsort(elementCounts, distinctElements, sizeof(ElementCount), compare); // 打印前n个元素 for (int i = 0; i < n && i < distinctElements; i++) { printf("Element: %d, Count: %d\n", elementCounts[i].value, elementCounts[i].count); } free(elementCounts); } int main() { int arr[] = {1, 3, 1, 3, 2, 1, 4, 5, 2, 3, 3, 4, 5, 4, 4, 4, 5}; int size = sizeof(arr) / sizeof(arr[0]); int n = 3; findTopNFrequent(arr, size, n); return 0; }
定义结构体 ElementCount：
value 存储数组元素的值。
count 存储该元素的出现次数。
统计每个元素的出现次数：
遍历数组 arr，如果 elementCounts 中已存在该元素，则增加其 count。
如果不存在，则将该元素及其 count 初始化为1，并记录到 elementCounts 中。
排序：
使用 qsort 对 elementCounts 数组按 count 从大到小排序。
输出前n个频率最高的元素：
遍历排序后的 elementCounts，输出前n个元素。
释放内存：
释放动态分配的内存 elementCounts。
通过这种方法，我们可以有效地找到数组中出现频率最高的前n个数。
要解决这个问题，我们需要计算所有可能的组合方式，使得100只骆驼总共能运送100筐土豆。我们可以通过设立不同的变量表示不同类型骆驼的数量，然后利用这些变量设立方程来解决问题。具体思路如下：
( x ) 表示大骆驼的数量（每只大骆驼可以背3筐土豆）。
( y ) 表示中骆驼的数量（每只中骆驼可以背2筐土豆）。
( z ) 表示小骆驼的数量（每2只小骆驼可以背1筐土豆，所以一只小骆驼相当于0.5筐）。
我们有以下两个约束条件：
骆驼总数为100只： [ x + y + z = 100 ]
背的土豆总数为100筐： [ 3x + 2y + 0.5z = 100 ]
从第一个方程我们可以得到： [ z = 100 - x - y ]
将 ( z ) 代入第二个方程： [ 3x + 2y + 0.5(100 - x - y) = 100 ]
解简化这个方程： [ 3x + 2y + 50 - 0.5x - 0.5y = 100 ] [ 2.5x + 1.5y = 50 ] [ 5x + 3y = 100 ]
现在我们只需要解这个方程就能得到所有的可能组合。具体步骤如下：
逐一尝试 ( x ) 的值从0到100之间的所有整数，判断是否有对应的 ( y ) 和 ( z ) 满足方程。
确保 ( x, y, z ) 都是非负整数。
我们可以使用简单的C语言代码来计算所有满足条件的组合。
#include int main() { int x, y, z; int count = 0; for (x = 0; x <= 100; x++) { for (y = 0; y <= 100; y++) { z = 100 - x - y; if (z >= 0 && (5 * x + 3 * y == 100)) { printf("大骆驼: %d, 中骆驼: %d, 小骆驼: %d\n", x, y, z); count++; } } } printf("组合的总数: %d\n", count); return 0; }
双重循环：外部循环遍历大骆驼的数量 ( x )，内部循环遍历中骆驼的数量 ( y )。
计算小骆驼的数量 ( z )：根据 ( z = 100 - x - y ) 计算。
判断条件：检查 ( z ) 是否为非负整数，并且检查方程 ( 5x + 3y = 100 ) 是否成立。
输出结果：如果条件满足，输出对应的 ( x, y, z ) 的值并计数。
这段代码会输出所有可能的骆驼组合，并且打印出组合的总数。