The technique you are seeking is generally called advanced or fancy indexing. The premise to fancy indexing is that you need indices of broadcastable size in each dimension. The corresponding elements at each location in the index arrays select a single element from the array being indexed. In your case, all that means is that you need to split I across the different dimensions. Since I is currently N x 3, you can do

C[tuple(I.T)] += 1

If you could pre-transpose I somehow, you could do

C[*I] += 1

Using the in-place increment is by far your best bet here. If you do

C[tuple(I.T)] = C[tuple(I.T)] + 1

a copy of the N indexed elements will be made. The copy will then be incremented, and reassigned correctly to the source array. You can imagine how this would be much more expensive than just incrementing values in place.

I support what @MadPhysicist suggested. The following elaborates on his suggestions and validates that you are getting consistent result.

Possible Methods

# method-1
C[I[:,0], I[:,1], I[:,2]] += 1

# method-2
C[tuple(I.T)] += 1

Solution in Detail

Make Dummy Data

I = np.vstack([
    np.random.randint(6, size=10), 
    np.random.randint(5, size=10), 
    np.random.randint(3, size=10), 
]).T
C = np.arange(90).reshape((6,5,3))
I

Output

array([[2, 3, 2],
       [1, 3, 2],
       [2, 0, 0],
       [0, 3, 0],
       [2, 0, 2],
       [2, 3, 2],
       [4, 0, 2],
       [2, 1, 2],
       [4, 1, 1],
       [1, 1, 1]])

First we use list comprehension

Here we do this to extract values from C while treating I as a subset of its indices. Thus we will know what to expect, if we follow what @MadPhysicist suggested.

I2 = [tuple(x) for x in tuple(I)]
[C[x] for x in I2]

Output

[41, 26, 30, 9, 32, 41, 62, 35, 64, 19]

Crosscheck

Let's see what is inside I2.

[(2, 3, 2),
 (1, 3, 2),
 (2, 0, 0),
 (0, 3, 0),
 (2, 0, 2),
 (2, 3, 2),
 (4, 0, 2),
 (2, 1, 2),
 (4, 1, 1),
 (1, 1, 1)]

So, this shows us that we have something tangible.

Test Other Methods

Method-1

C[I[:,0], I[:,1], I[:,2]]

Method-2

C[tuple(I.T)]

Output

Both the methods 1 and 2 produce the same as before.

array([41, 26, 30,  9, 32, 41, 62, 35, 64, 19])

Ok. So Indexing Problem is Over.

Now we address the problem posed in this question. Use, either method-1 or method-2 below. Method-2 is more concise (as suggested by @MadPhysicist).

# method-1
C[I[:,0], I[:,1], I[:,2]] += 1

# method-2
C[tuple(I.T)] += 1

Quick Test

Here is a quick test first (without changing C first) as a safety precaution.

B = C.copy()
B[tuple(I.T)] += 1
B[tuple(I.T)]

Output

array([42, 27, 31, 10, 33, 42, 63, 36, 65, 20])

So, it works!

You could do something like this:

In [3]: c = np.array([[1, 2, 3], [2, 3, 4], [3, 4, 5]])                                       

In [4]: c                                                                                     
Out[4]: 
array([[1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]])

In [5]: i = [0, 2]                                                                            

In [6]: c[i]                                                                                  
Out[6]: 
array([[1, 2, 3],
       [3, 4, 5]])

In [7]: c[i] + 1                                                                              
Out[7]: 
array([[2, 3, 4],
       [4, 5, 6]])

1. you could simply do it as c[i] where i is the indices. ([5] in above.)
2. you can simply let numpy handle that stuff. Incrementing by 1 or adding some scalar to a matrix is handled by broadcasting the scalar. As for whether it is faster, I don't know. You can read more about it here: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html

Hope that helps.