What's the best way to use std::list container with std::map

Is it valid to create a pointer to an std::list container in C++? The sample program seems to be working fine.

#include <iostream>
#include <list>
#include <map>

int main()
{
    std::map<int, std::list<int>*> map_list;

    std::list<int>* my_list = new std::list<int>;
    my_list->push_back(10);
    my_list->push_back(20);

    map_list.emplace(1, my_list);

    for (auto maplist : map_list)
    {
        std::cout<<"KEY:"<<maplist.first<<std::endl;
        std::cout<<"std::list<int>* PTR:"<<maplist.second<<std::endl;

        auto mylist = *(maplist.second);
        for (auto x : mylist)
        {
            std::cout<<"Value:"<<x<<std::endl;
        }
    }

    /*resource release*/
    for (auto maplist : map_list)
    {
        std::cout<<"KEY:"<<maplist.first<<std::endl;
        std::cout<<"std::list<int>* PTR:"<<maplist.second<<std::endl;

        maplist.second->clear();
        delete maplist.second;
    }
    map_list.clear();
    return 0;
}

I am wondering if this practice is advisable, or if there is anything wrong with the way I am creating a pointer to the std::list container.

Using raw pointers is dangerous; makes it too easy to leak memory. std::list is pretty cheap to move though, so you could just skip the pointer and get the same basic behaviors with roughly equivalent performance (if anything, slightly better due to avoiding an extra layer of indirection):

#include <iostream>
#include <list>
#include <map>

int main()
{
    std::map<int, std::list<int>> map_list;  // No pointers!

    std::list<int> my_list;  // No new
    my_list.push_back(10);   // No pointers, so . over ->
    my_list.push_back(20);

    map_list.emplace(1, std::move(my_list));  // Move into map, avoid copy

    for (const auto& maplist : map_list)  // Iterate by reference, avoid copies; never modified, so const is good
    {
        std::cout<<"KEY:"<<maplist.first<<std::endl;

        const auto& mylist = maplist.second;  // Use reference to avoid copy
        for (auto x : mylist)  // It's just integers so references unnecessary here
        {
            std::cout<<"Value:"<<x<<std::endl;
        }
    }

    // No need for resource release at all; the `map` will clean its RAII managed contents automatically
    return 0;
}

Saves all the explicit code for cleanup, and uses move-semantics and references to avoid unnecessary copy work (admittedly pretty trivial in the program as written, with just one length 2 list, but copying many larger lists would be much more expensive than just referencing their contents, with no copies involved).