How can memory size be 1M x 16?
It seems that a bunch of different things are being conflated here:


Bits in an addressable memory location - 16 in this example.
Addressable memory locations - 1M = 2^20 in this example.
CPU word size


These can all be the same, or they can be entirely different. I will try to explain the differences:

1 - Bits in an addressable word. This can be ANYTHING. Typically this will be the same as the CPU word size - e.g., 32-bits for a 32-bit processor. However, it can be larger (e.g., direct access to a "double word") or smaller (e.g., individual byte access for a CPU that has a 16-bit or larger word size). On some CPUs there will be different instructions that use different size operands and addressing schemes - e.g., floating point instructions might work only on 32-bit ("single word") or 64-bit ("double word") memory locations but other instructions might work with individual bytes. In some designs, every byte can be addressed and accessed directly but 16-bit words only on even addresses (or 32-bit only on addresses divisible by 4).

2 - Addressable memory locations. Historically this was often double the addressable memory location size. For example, a typical 8-bit CPU such as the Z80 or 6502 could directly address 64k = 2^16 memory locations. However, there are quite a few variations. One significant one is a segmented memory addressing scheme such as that used by the 8086 family. This is one method of expanding the total addressable memory while keeping the addresses directly used by most instructions to a smaller size (16-bit in the case of the 8086). While there is some logic to keeping the address size (=# of addressable memory locations) the same as the CPU word size, in many (most?) CPU architectures that was simply not practical in many cases until we arrived at the era of affordable 64-bit CPUs.

3 - CPU word size. The CPU word size normally refers to the standard chunks of memory operated on and produced as results by individual CPU instructions. Another way of looking at it is the register size. However, there have been exceptions here as well. For example, the 8-bit 8080 has 7 8-bit registers and 2 16-bit registers (SP and PC - both needed to be 16-bit to match the memory address size) and some of the 8-bit registers could be used in pairs for operations that really operated on 16 bit values. Similarly, many 16-bit CPUs have some instructions that operate on 32-bit quantities either for floating point arithmetic or again for memory addressing.

Now that I've rambled on a bit (pun intended), back to the original question: 1M = 2^20, while the max number of memory locations for 16 bits is 2^16. How could there be a memory size of 1M x 16?
A few possibilities come to mind:


16-bit CPU with memory locations 16-bits wide and a 20-bit segmented architecture like the 8086. (But not actually the 8086 as the 8086 address space was 1M x 8)
16-bit CPU with a 20-bit or larger (typically 31-bit or 32-bit) total word-addressable memory with the 1M being just a small portion of the potential addressable memory for that particular CPU.
16-bit CPU with 21-bit or larger (typically 31-bit or 32-bit) total byte-addressable memory with the 1M just being a small portion of the potential addressable memory for that particular CPU.
32-bit CPU with memory addressable in 16-bit words (i.e., 1/2 the native CPU word size) for better performance with instructions that don't need 32-bit words.


In case it isn't already clear, the CPU word size historically directly translated to the number of pins available for reading/writing memory. So an 8-bit CPU could interface with memory 8-bits at a time and a 16-bit CPU 16-bits at a time. That all changed famously with the 8088 which internally was a 16-bit CPU but externally only 8-bits. So while the 8086 could directly use 16-bit wide memory like the example 1M x 16, the 8088 could not. That difference gives the 8088 performance that is in some ways closer to an 8-bit CPU than a 16-bit CPU.