leetcode No.1787 使所有区间异或和为0

整体题目用到动态规划思想， 首先很容易得出nums[i] = nums[i + k];故题目要求即可简化
接下来求前i列异或和为xor， 当前列数字为cur。
若是第零列， 那么f[0][xor] = times - hashTable.get(xor);
若是后面几列，
若当前列数字全改， f[i][xor] = minval[i] + times;
若仅修改部分数字， f[i][xor] = f[i - 1][xor ^ cur] + times - hashTable.get(cur);
然后去求最小

C语言题解如下：

#define MAX 1024

typedef struct {
	int key;
	int times;
}Hash;
typedef struct {
	Hash* hash;
	int num;
}HashTable;

typedef HashTable* Table;

void AddHash(Table table, int num);
int SearchHash(Table table, int num);
int Min(int a, int b);
void InitializeTable(Hash* hash, Table table);
int minChanges(int* nums, int numsSize, int k)
{
	Hash hash[2000];
	HashTable table;

	int xor;
	int f[2000][MAX] = { 0 };
	int times;
    int temp[2];    //temp[0]stage the prev, temp[1]stage the current.
	for (int i = 0; i < k; i++)
	{
        temp[1] = 2147483647;
		times = 0;
		InitializeTable(hash, &table);
		//读入哈希表
		for (int j = i; j < numsSize; j += k)
		{
			AddHash(&table, nums[j]);
			times++;
		}
		if (i == 0)
		{
			for (xor = 0; xor < MAX; xor ++)
			{
				f[0][xor] = times - SearchHash(&table, xor);
				temp[1] = Min(temp[1], f[0][xor]);
			}
		}
		else
		{
			for (xor = 0; xor < MAX; xor++)
			{
                f[i][xor] = temp[0] + times;
				for (int j = 0; j < table.num; j++)
				{
                    int cur = hash[j].key;
					f[i][xor] =Min(f[i][xor], f[i - 1][xor ^cur] + times - SearchHash(&table, cur));
                }
            
            temp[1] = Min(f[i][xor], temp[1]);
            }
		}
        temp[0] = temp[1];
	}
	return f[k - 1][0];
}
void AddHash(Table table, int num)
{
	Hash* node = table->hash;
	if (SearchHash(table, num) == 0)
	{
		node[(table->num)].times = 1;
		node[(table->num)].key = num;
		(table->num)++;
	}
	else
	{
		for (int i = 0; i < table->num; i++)
		{
			if (node[i].key == num)
			{
				node[i].times++;
				break;
			}
		}
	}
	return;
}

int SearchHash(Table table, int num)
{
	Hash* node = table->hash;
	for (int i = 0; i < table->num; i++)
	{
		if (node[i].key == num)
			return node[i].times;
	}
	return 0;
}
int Min(int a, int b)
{
	return a < b ? a : b;
}
void InitializeTable(Hash* hash, Table table)
{
	table->num = 0;
	table->hash = hash;
}

java题解如下：

import java.util.*;
class Solution {
    public int minChanges(int[] nums, int k) 
    {
        final int MAX = 1024;
        int n = nums.length;
        var table = new Hashtable<Integer, Integer>();
        int[][] f = new int[k][MAX];
        int[] minval = new int[2];
        int times = 0;
        for(int i = 0; i < k; i++)
        {
            minval[1] = 2147483647;
            table.clear();
            times = 0;
            for(int j = i; j < n; j+=k)
            {
                    table.put(nums[j], (Integer)table.getOrDefault(nums[j], 0) + 1) ;
                    times++;
            }
            //初始化哈希表
            if(i == 0)
            {
                for(int xor = 0; xor < MAX; xor++)
                {
                    f[0][xor] = times - table.getOrDefault(xor, 0);
                    minval[1] = Math.min(f[0][xor], minval[1]);
                }
            }
            else
            {
                for (int xor = 0; xor < MAX; xor++)
                {
                    //全改
                    f[i][xor] = minval[0] + times;
                    for (int cur : table.keySet())
                    {
                        f[i][xor] = Math.min(f[i][xor], f[i - 1][xor ^ cur] + times - table.get(cur));
                    }             
                    minval[1] = Math.min(minval[1], f[i][xor]);
                }
            }
            minval[0] = minval[1];
        }
        return f[k  - 1][0];
    }
}

其中， 数组单元可以进行优化， 这个就不在这里赘述