最后更新：2019-2-28

        如图，0xc000007b这个错误使无数玩家烦恼。



问题描述：

        出现这个错误，可能是硬件的问题，也可能是软件的问题。但是，由于硬件引起该问题的概率很小，并且除了更换硬件之外没有更好的解决方法，因此本文将详细介绍如何通过软件解决此问题，这也是大家最关心的。由于本文阅读用户众多，大家对于电脑故障解决的熟悉程度也不一样，因此本文致力于用最通俗的语言，提供最简便的解决方法，满足绝大多数用户的需求。如果您是高级用户，也可以查看我的后续文章，查看问题具体原因分析。

  

        一句话介绍一下这个错误的意思。0xc000007b的意思是因dll文件调用异常而抛出的错误代码。那么我们平时玩游戏（吃鸡、极品飞车、FIFA等等）、用的工业软件（3ds max、maya、autodesk系列等等），究竟是哪些dll文件或者组件会存在异常呢？答案是DirectX（并且多数情况下是DirectX 9.0），以及Visual C++ Redistributable Package。

  

        也许大家会问了：我玩的游戏都有DirextX 11的特效了，还会和DirectX 9有关系吗？事实上，游戏公司为了游戏的兼容性，往往都是基于DirectX 9.0的API开发游戏，然后加上DirectX 10和DirectX 11的特效，这样的话，不管什么样的显卡都可以玩游戏。也正是如此，DirectX 9.0有问题会影响目前最新的游戏。还有人会问了：我的Windows 7都能支持DirectX 11了，Windows 10都支持DirectX 12了，怎么还不行？这里要做两点说明，首先，Windows 7是最高支持DirectX 11，向下兼容DirectX 9以及DirectX 10，并不是Windows 7只支持DirectX 11；还有，原版的Windows中只包含了最基本的DirectX组件，而游戏需要的往往是较高级的组件（如d3dx9_42.dll、xinput1_3.dll），系统缺失这些关键的文件会造成游戏无法运行或出现0xc000007b错误。还有人会问：我已经装过DirectX 9.0了，也安装过c++了，还是不管用呀？这里有一个很大的误区，就是用64位系统的用户认为只需要安装64位的组件。这是不对的，因为游戏开发商为了游戏兼容性，往往都是在32位系统上开发的程序，以便可以同时兼容32位系统和64位系统，所以在64位系统上也必须同时安装32位和64位的库文件才行。重要的事情再重复一遍：32位系统要安装32位的DirectX和c++库文件，而64位系统一定要同时安装32位和64位的库文件，这是解决这个问题的关键。

 

解决方法：  

        说到这，大家自然就知道解决方法了——安装最新版的DirectX和c++组件。诚然，自己去一个一个的文件下载然后安装可能能解决问题，但是在网上搜过c++的朋友一定会知道，c++的版本太多了（感兴趣的用户可以参见我的博客《破解C++ Redistributable Package版本之谜》），究竟要下哪个才能解决我的问题？一个一个去找岂不是要累s？别着急，这里我给大家提供一个一劳永逸的终极解决办法：使用0xc000007b问题的克星——DirectX修复工具。

 

        简便万能、一键修复的DirectX修复工具。鉴于组件版本众多单独安装复杂，本人特地亲自编写了一款绿色软件——DirectX修复工具。该款软件采用傻瓜式一键操作，只要点一个按钮，就能自动完成校验、检测、修复、注册的功能，可以多线程操作同时修复DirectX组件以及c++组件的异常，十分简便易用。该软件可支持Windows XP、Windows Vista、Windows 7、Windows 8、Windows 8.1、Windows 10等所有Windows操作系统，可以自适应兼容32位与64位操作系统。大家完全不必操心自己的操作系统到底是什么操作系统，需要做的只是下载该软件，然后运行，因此极力推荐普通用户使用该方法。

增强版程序链接：https://blog.csdn.net/VBcom/article/details/7245186

        请大家到上述链接下载最新版的修复工具，运行后点击“检测并修复”按钮，待全部文件修复成功后（如提示需要重启请按要求重启），你就可以试试你的游戏了。双击游戏图标，游戏运行了~~

 

编后语：

        DirectX修复工具是0xc000007b这个问题的克星，综合用户的反馈情况，有效率高达95%以上。诚然，即使这么高的成功率，也不是100%，也会有极少数用户用过DirectX修复工具还没解决0xc000007b问题。如果您还有0xc000007b问题急需解决的，可以加我预约有偿远程调试（DirectX修复工具已经能解决95%的0xc000007b问题了，剩下解决不了的都是一些疑难杂症，需要一定的时间精力远程查看分析问题，故收取一定费用，请谅解），或者查看本文的后续文章《0xc000007b的解决办法（续）》，在里面继续查看其他详细的解决办法；如果文章中的方法解决了你的问题，不要忘了回复一下哦！

        另外，如果你想对作者表示更大的感谢，也可以给予作者资金上的支持。只要下载前面置顶方法里介绍的DirectX修复工具，在其中的“帮助”菜单中有一个“捐赠”选项（如下图），按照提示即可给予作者资金上的帮助。对各位的支持深表感谢！ 





 

总结：

        游戏、工业软件出现0xc000007b错误，多是由于DirectX组件异常或者c++组件异常导致的。最简便的解决办法是使用DirectX修复工具进行一键修复，基本上可以解决95%的此类问题。如果修复后还没解决或者在使用DirectX修复工具时遇到问题，可以参看我的后续文章《0xc000007b的解决办法（续）》寻求进一步的解决方法。

0-1背包问题
给定n个重量为$w_1$，$w_2$,$w_3$,…,$w_n$，价值为$v_1$,$v_2$,$v_3$,…,$v_n$的物品和容量为$C$的背包，求这个物品中一个最有价值的子集，使得在满足背包的容量的前提下，包内的总价值最大
0-1背包问题指的是每个物品只能使用一次
递归方法
首先我们用递归的方式来尝试解决这个问题

我们用$F(n,C)$表示将前$n$个物品放进容量为$C$的背包里，得到的最大的价值。

我们用自顶向下的角度来看，假如我们已经进行到了最后一步（即求解将$n$个物品放到背包里获得的最大价值），此时我们便有两种选择

不放第$n$个物品，此时总价值为$F(n-1,C)$
放置第$n$个物品，此时总价值为$v_n+F(n-1,C-w_n)$

两种选择中总价值最大的方案就是我们的最终方案，递推式（有时也称之为状态转移方程）如下

$F(i,C)=max(F(i-1,C),v(i)+F(i-1,C-w(i)))$

编程实现如下：
public class KnapSack01 {
    /**
     * 解决背包问题的递归函数
     *
     * @param w        物品的重量数组
     * @param v        物品的价值数组
     * @param index    当前待选择的物品索引
     * @param capacity 当前背包有效容量
     * @return 最大价值
     */
    private static int solveKS(int[] w, int[] v, int index, int capacity) {
        //基准条件：如果索引无效或者容量不足，直接返回当前价值0
        if (index < 0 || capacity <= 0)
            return 0;

        //不放第index个物品所得价值
        int res = solveKS(w, v, index - 1, capacity);
        //放第index个物品所得价值（前提是：第index个物品可以放得下）
        if (w[index] <= capacity) {
            res = Math.max(res, v[index] + solveKS(w, v, index - 1, capacity - w[index]));
        }
        return res;
    }

    public static int knapSack(int[] w, int[] v, int C) {
        int size = w.length;
        return solveKS(w, v, size - 1, C);
    }

    public static void main(String[] args){
        int[] w = {2,1,3,2};
        int[] v = {12,10,20,15};
        System.out.println(knapSack(w,v,5));
    }
}


记忆化搜索
我们用递归方法可以很简单的实现以上代码，但是有个严重的问题就是，直接采用自顶向下的递归算法会导致要不止一次的解决公共子问题，因此效率是相当低下的。

我们可以将已经求得的子问题的结果保存下来，这样对子问题只会求解一次，这便是记忆化搜索。

下面在上述代码的基础上加上记忆化搜索
public class KnapSack01 {
    private static int[][] memo;

    /**
     * 解决背包问题的递归函数
     *
     * @param w        物品的重量数组
     * @param v        物品的价值数组
     * @param index    当前待选择的物品索引
     * @param capacity 当前背包有效容量
     * @return 最大价值
     */
    private static int solveKS(int[] w, int[] v, int index, int capacity) {
        //基准条件：如果索引无效或者容量不足，直接返回当前价值0
        if (index < 0 || capacity <= 0)
            return 0;

        //如果此子问题已经求解过，则直接返回上次求解的结果
        if (memo[index][capacity] != 0) {
            return memo[index][capacity];
        }

        //不放第index个物品所得价值
        int res = solveKS(w, v, index - 1, capacity);
        //放第index个物品所得价值（前提是：第index个物品可以放得下）
        if (w[index] <= capacity) {
            res = Math.max(res, v[index] + solveKS(w, v, index - 1, capacity - w[index]));
        }
        //添加子问题的解，便于下次直接使用
        memo[index][capacity] = res;
        return res;
    }

    public static int knapSack(int[] w, int[] v, int C) {
        int size = w.length;
        memo = new int[size][C + 1];
        return solveKS(w, v, size - 1, C);
    }

    public static void main(String[] args) {
        int[] w = {2, 1, 3, 2};
        int[] v = {12, 10, 20, 15};
        System.out.println(knapSack(w, v, 5));
    }
}


动态规划算法



public class KnapSack01 {
    public static int knapSack(int[] w, int[] v, int C) {
        int size = w.length;
        if (size == 0) {
            return 0;
        }

        int[][] dp = new int[size][C + 1];
        //初始化第一行
        //仅考虑容量为C的背包放第0个物品的情况
        for (int i = 0; i <= C; i++) {
            dp[0][i] = w[0] <= i ? v[0] : 0;
        }
		//填充其他行和列
        for (int i = 1; i < size; i++) {
            for (int j = 0; j <= C; j++) {
                dp[i][j] = dp[i - 1][j];
                if (w[i] <= j) {
                    dp[i][j] = Math.max(dp[i][j], v[i] + dp[i - 1][j - w[i]]);
                }
            }
        }
        return dp[size - 1][C];
    }

    public static void main(String[] args) {
        int[] w = {2, 1, 3, 2};
        int[] v = {12, 10, 20, 15};
        System.out.println(knapSack(w, v, 5));
    }
}


空间复杂度的极致优化
上面的动态规划算法使用了O(n*C)的空间复杂度（因为我们使用了二维数组来记录子问题的解），其实我们完全可以只使用一维数组来存放结果，但同时我们需要注意的是，为了防止计算结果被覆盖，我们必须从后向前分别进行计算



我们仍然假设背包空间为5，根据$F(i,C)=max(F(i-1,C),v(i)+F(i-1,C-w(i)))$我们可以知道，当我们利用一维数组进行记忆化的时候，我们只需要使用到当前位置的值和该位置之前的值，举个例子

假设我们要计算$F(i,4)$,我们需要用到的值为$F(i-1,4)$和$F(i-1,4-w(i))$,因此为了防止结果被覆盖，我们需要从后向前依次计算结果

最终的动态规划代码如下
public class KnapSack01 {
    public static int knapSack(int[] w, int[] v, int C) {
        int size = w.length;
        if (size == 0) {
            return 0;
        }

        int[] dp = new int[C + 1];
        //初始化第一行
        //仅考虑容量为C的背包放第0个物品的情况
        for (int i = 0; i <= C; i++) {
            dp[i] = w[0] <= i ? v[0] : 0;
        }

        for (int i = 1; i < size; i++) {
            for (int j = C; j >= w[i]; j--) {
                dp[j] = Math.max(dp[j], v[i] + dp[j - w[i]]);
            }
        }
        return dp[C];
    }

    public static void main(String[] args) {
        int[] w = {2, 1, 3, 2};
        int[] v = {12, 10, 20, 15};
        System.out.println(knapSack(w, v, 5));
    }
}


利用背包问题的思想解决问题
leetcode 416 Partition Equal Subset Sum

给定一个仅包含正整数的非空数组，确定该数组是否可以分成两部分，要求两部分的和相等

问题分析
该问题我们可以利用背包问题的思想进行求解。
假设给定元素个数为$n$的数组arr，数组元素的和为sum，对应于背包问题，等价于有$n$个物品，每个物品的重量和价值均为为arr[i]，背包的限重为sum/2，求解背包中的物品最大价值为多少？
class Solution {
    private boolean knapSack(int[] nums,int sum){
        int size = nums.length;
        
        boolean[] dp = new boolean[sum + 1];
        for (int i = 0;i <= sum;i ++){
           dp[i] = i == nums[0];
        }
        
        for (int i = 1;i < size;i++){
            for (int j = sum;j >= nums[i];j--){
                dp[j] = dp[j] || dp[j-nums[i]];
            }
        }
        return dp[sum];
    }
    
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int item : nums){
            sum += item;
        }
        
        //如果数组元素和不是2的倍数，直接返回false
        if (sum % 2 != 0)
            return false;
        
        return knapSack(nums,sum/2);
    }
}

成功解决IndexError: index 0 is out of bounds for axis 1 with size 0

 

目录

解决问题

解决思路

解决方法

 

 

解决问题

IndexError: index 0 is out of bounds for axis 1 with size 0

 

 

 

解决思路

查看列表，输出列表内容，查看列表的形状，发现列表的确是空值，所以修改列表内容即可！

print(list.shape)

 

 

 

解决方法

y = train_np[:, 0]

print(train_np)  


#修改列表的内容使其不为空列表即可！

大功告成！哈哈！

在说明这个问题前，首先要搞明白 什么是ASCII码值

不明白的看以下链接中的ASCII 字符代码表：

https://baike.baidu.com/pic/ASCII/309296/0/e850352ac65c103880a07b53bc119313b17e8941?fr=lemma&ct=single#aid=0&pic=e850352ac65c103880a07b53bc119313b17e8941

①    ‘0’    代表    字符0  ，对应ASCII码值为   0x30 (也就是十进制 48)

②    '\0'    代表     空字符(转义字符)【输出为空】， 对应ASCII码值为   0x00(也就是十进制 0)， 用作字符串结束符

③     0    代表     数字0，  若把 数字0 赋值给 某个字符，对应ASCII码值为    0x00(也就是十进制0) 

④     “0”  代表    一个字符串，  字符串中含有 2个字符，分别是 '0' 和  '\0'   

下面补充说明（帮助理解）

①   char  ch_0 = ‘0’;                   // 字符0 赋值给一个字符，实际赋的 码值 为 0x30，十进制48

      std::cout << ch_0 << '\n';      // 输出的 是 码值0x30 对应的 字符 0， 界面上看到的是0

      std::cout << int(ch_0) << '\n';    // 输出的 是字符 ‘0’ 对应的码值  0x30，即十进制48  ，界面上看到的是 48

②   char  ch_0 =  '\0';                 // 字符‘\0' 赋值给一个字符，实际赋的 码值 为 0x00，十进制0

      std::cout << ch_0 << '\n';     // 输出的 是 码值0x00 对应的 空字符【NULL】， 界面上看到的是 空白，什么也看不见

      std::cout << int(ch_0) << '\n';    // 输出的 是字符 ‘\0’ 对应的码值  0x00，即十进制0  ，界面上看到的是 0

③   char  ch_0 = 0;                    // 数字0 赋值给一个字符，实际赋的是 码值

       std::cout << ch_0 << '\n';    // 输出的 是 码值0 对应的 字符，此处为 空白字符，即输出为空，界面上什么也看不见

      std::cout << int(ch_0) << '\n';    // 输出的 是码值  0x00，即十进制0  ，界面上看到的是0

④   char ch_0[ ] = "0";               // 字符串 “0” 初始化字符数组

      std::cout << sizeof(ch_0) << ‘\n’;     // 输出 ch_0 字节数， 界面显示 为2

      std::cout << ch_0[0] << '\n';             // 输出字符 ‘0’，界面上看到的是 0 

      std::cout << ch_0[1] << '\n';            // 输出字符 ‘\0’，界面上看到的是 空白

      std::cout << int( ch_0[0] )<< '\n';     // 输出字符 ‘0’ 对应的码值 0x30，界面上看到的是 48

      std::cout << int ( ch_0[1] )<< '\n';    // 输出字符 ‘\0’ 对应的码值 0x00，界面上看到的是 0

 

注：以上代码 若是想拷贝试试，可能需要做相应的调整。因为为了方便大家学习，我有些地方多加了空格，能看得更清楚些，有问题欢迎留言探讨。

总结：记住几点

① 用 数值 给 某个 字符变量 赋值时，相当赋 与该数字相同码值 所对应的字符

② 用 字符 给 某个 字符变量赋值时， 即 赋 字符本身

③ ‘\0’ 对应的 码值为0， 界面显示为 空白